XEvent Profiler initial event handlers (#456)

* Bump SMO to 140.2.5 to pick-up private XEvent binaries

* Pick up SMO binaries from the build lab

* Add ProfilerService class placeholder

* Update SMO nuget package to include DB Scoped XEvents

* Stage changes

* Stage changes

* Update SMO to use RTM dependencies and remove separate SqlScript package

* Stage changes

* Iterate on profiler service

* Fix post-merge break in localization

* More refactoring

* Continue iterating on profiler

* Add test profiler listener

* Address a couple of the code review feedback

* Fix AppVeyor build break

* Use self-cleaning test file

src/Microsoft.SqlTools.Credentials/Microsoft.SqlTools.Credentials.csproj

@@ -19,8 +19,7 @@
   </ItemGroup>
   <ItemGroup>
 	<PackageReference Include="System.Data.SqlClient" Version="4.4.0" />
-	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.4" />
+	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.5" />
-	<PackageReference Include="Microsoft.SqlServer.Management.SqlScriptPublishModel" Version="140.2.4" />
 	<PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
 	<PackageReference Include="Microsoft.Extensions.DependencyModel" Version="2.0.0" />
 	<PackageReference Include="System.Runtime.Loader" Version="4.3.0" />

src/Microsoft.SqlTools.Hosting/Microsoft.SqlTools.Hosting.csproj

@@ -14,8 +14,7 @@
   </PropertyGroup>
   <ItemGroup>
 	<PackageReference Include="System.Data.SqlClient" Version="4.4.0" />
-	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.4" />
+	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.5" />
-	<PackageReference Include="Microsoft.SqlServer.Management.SqlScriptPublishModel" Version="140.2.4" />
 	<PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
 	<PackageReference Include="Microsoft.Extensions.DependencyModel" Version="2.0.0" />
 	<PackageReference Include="System.Runtime.Loader" Version="4.3.0" />

src/Microsoft.SqlTools.ServiceLayer/Connection/ConnectionService.cs

@@ -9,6 +9,7 @@ using System.Collections.Generic;
 using System.Data;
 using System.Data.Common;
 using System.Data.SqlClient;
+using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -1086,5 +1087,40 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection
                 }
             }
         }
+
+        /// <summary>
+        /// Create and open a new SqlConnection from a ConnectionInfo object
+        /// Note: we need to audit all uses of this method to determine why we're
+        /// bypassing normal ConnectionService connection management
+        /// </summary>
+        internal static SqlConnection OpenSqlConnection(ConnectionInfo connInfo)
+        {
+            try
+            {                 
+                // increase the connection timeout to at least 30 seconds and and build connection string
+                // enable PersistSecurityInfo to handle issues in SMO where the connection context is lost in reconnections
+                int? originalTimeout = connInfo.ConnectionDetails.ConnectTimeout;
+                bool? originalPersistSecurityInfo = connInfo.ConnectionDetails.PersistSecurityInfo;
+                connInfo.ConnectionDetails.ConnectTimeout = Math.Max(30, originalTimeout ?? 0);
+                connInfo.ConnectionDetails.PersistSecurityInfo = true;
+                string connectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails);
+                connInfo.ConnectionDetails.ConnectTimeout = originalTimeout;
+                connInfo.ConnectionDetails.PersistSecurityInfo = originalPersistSecurityInfo;
+
+                // open a dedicated binding server connection
+                SqlConnection sqlConn = new SqlConnection(connectionString); 
+                sqlConn.Open();
+                return sqlConn;
+            }
+            catch (Exception ex)
+            {
+                string error = string.Format(CultureInfo.InvariantCulture, 
+                    "Failed opening a SqlConnection: error:{0} inner:{1} stacktrace:{2}",
+                    ex.Message, ex.InnerException != null ? ex.InnerException.Message : string.Empty, ex.StackTrace);
+                Logger.Write(LogLevel.Error, error);
+            }
+            
+            return null;
+        }
     }
 }

src/Microsoft.SqlTools.ServiceLayer/Connection/Contracts/ConnectionDetails.cs

@@ -22,8 +22,8 @@ namespace Microsoft.SqlTools.ServiceLayer.Connection.Contracts
         /// <summary>
         /// Gets or sets the connection password
         /// </summary>
-        /// <returns></returns>
+        public string Password 
-        public string Password {
+        {
             get
             {
                 return GetOptionValue<string>("password");

src/Microsoft.SqlTools.ServiceLayer/DisasterRecovery/DisasterRecoveryService.cs

@@ -143,8 +143,8 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
                 if (connInfo != null)
                 {
                     DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true);
-                    SqlConnection sqlConn = GetSqlConnection(connInfo);
+                    SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo);
-                    if ((sqlConn != null) && !connInfo.IsSqlDW && !connInfo.IsAzure)
+                    if (sqlConn != null && !connInfo.IsSqlDW && !connInfo.IsAzure)
                     {
                         BackupConfigInfo backupConfigInfo = this.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
                         backupConfigInfo.DatabaseInfo = AdminService.GetDatabaseInfo(connInfo);
@@ -296,7 +296,7 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
                 if (supported && connInfo != null)
                 {
                     DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(connInfo, databaseExists: true);
-                    SqlConnection sqlConn = GetSqlConnection(connInfo);
+                    SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo);
 
                     BackupOperation backupOperation = CreateBackupOperation(helper.DataContainer, sqlConn, backupParams.BackupInfo);
                     SqlTask sqlTask = null;
@@ -320,32 +320,6 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
             }
         }
 
-        internal static SqlConnection GetSqlConnection(ConnectionInfo connInfo)
-        {
-            try
-            {
-                // increase the connection timeout to at least 30 seconds and and build connection string
-                // enable PersistSecurityInfo to handle issues in SMO where the connection context is lost in reconnections
-                int? originalTimeout = connInfo.ConnectionDetails.ConnectTimeout;
-                bool? originalPersistSecurityInfo = connInfo.ConnectionDetails.PersistSecurityInfo;
-                connInfo.ConnectionDetails.ConnectTimeout = Math.Max(30, originalTimeout ?? 0);
-                connInfo.ConnectionDetails.PersistSecurityInfo = true;
-                string connectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails);
-                connInfo.ConnectionDetails.ConnectTimeout = originalTimeout;
-                connInfo.ConnectionDetails.PersistSecurityInfo = originalPersistSecurityInfo;
-
-                // open a dedicated binding server connection
-                SqlConnection sqlConn = new SqlConnection(connectionString);
-                sqlConn.Open();
-                return sqlConn;
-            }
-            catch (Exception)
-            {
-            }
-
-            return null;
-        }
-
         private bool IsBackupRestoreOperationSupported(string ownerUri, out ConnectionInfo connectionInfo)
         {
             SqlConnection sqlConn = null;
@@ -358,8 +332,8 @@ namespace Microsoft.SqlTools.ServiceLayer.DisasterRecovery
 
                 if (connInfo != null)
                 {
-                    sqlConn = GetSqlConnection(connInfo);
+                    sqlConn = ConnectionService.OpenSqlConnection(connInfo);
-                    if ((sqlConn != null) && !connInfo.IsSqlDW && !connInfo.IsAzure)
+                    if (sqlConn != null && !connInfo.IsSqlDW && !connInfo.IsAzure)
                     {
                         connectionInfo = connInfo;
                         return true;

src/Microsoft.SqlTools.ServiceLayer/FileBrowser/FileBrowserService.cs

@@ -114,7 +114,7 @@ namespace Microsoft.SqlTools.ServiceLayer.FileBrowser
         {
             try
             {
-                Task.Run(() => RunFileBrowserOpenTask(fileBrowserParams));
+                var task = Task.Run(() => RunFileBrowserOpenTask(fileBrowserParams));
                 await requestContext.SendResult(true);
             }
             catch
@@ -129,7 +129,7 @@ namespace Microsoft.SqlTools.ServiceLayer.FileBrowser
         {
             try
             {
-                Task.Run(() => RunFileBrowserExpandTask(fileBrowserParams));
+                var task = Task.Run(() => RunFileBrowserExpandTask(fileBrowserParams));
                 await requestContext.SendResult(true);
             }
             catch
@@ -144,7 +144,7 @@ namespace Microsoft.SqlTools.ServiceLayer.FileBrowser
         {
             try
             {
-                Task.Run(() => RunFileBrowserValidateTask(fileBrowserParams));
+                var task = Task.Run(() => RunFileBrowserValidateTask(fileBrowserParams));
                 await requestContext.SendResult(true);
             }
             catch

src/Microsoft.SqlTools.ServiceLayer/HostLoader.cs

@@ -15,6 +15,7 @@ using Microsoft.SqlTools.ServiceLayer.EditData;
 using Microsoft.SqlTools.ServiceLayer.Hosting;
 using Microsoft.SqlTools.ServiceLayer.LanguageServices;
 using Microsoft.SqlTools.ServiceLayer.Metadata;
+using Microsoft.SqlTools.ServiceLayer.Profiler;
 using Microsoft.SqlTools.ServiceLayer.QueryExecution;
 using Microsoft.SqlTools.ServiceLayer.Scripting;
 using Microsoft.SqlTools.ServiceLayer.SqlContext;
@@ -94,6 +95,9 @@ namespace Microsoft.SqlTools.ServiceLayer
             DisasterRecoveryService.Instance.InitializeService(serviceHost);
             serviceProvider.RegisterSingleService(DisasterRecoveryService.Instance);
 
+            ProfilerService.Instance.InitializeService(serviceHost);
+            serviceProvider.RegisterSingleService(ProfilerService.Instance);            
+
             InitializeHostedServices(serviceProvider, serviceHost);
             serviceHost.ServiceProvider = serviceProvider;
 

src/Microsoft.SqlTools.ServiceLayer/LanguageServices/ConnectedBindingQueue.cs

@@ -81,20 +81,7 @@ namespace Microsoft.SqlTools.ServiceLayer.LanguageServices
                 try
                 {
                     bindingContext.BindingLock.Reset();
-
+                    SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo);
-                    // increase the connection timeout to at least 30 seconds and and build connection string
-                    // enable PersistSecurityInfo to handle issues in SMO where the connection context is lost in reconnections
-                    int? originalTimeout = connInfo.ConnectionDetails.ConnectTimeout;
-                    bool? originalPersistSecurityInfo = connInfo.ConnectionDetails.PersistSecurityInfo;
-                    connInfo.ConnectionDetails.ConnectTimeout = Math.Max(DefaultMinimumConnectionTimeout, originalTimeout ?? 0);
-                    connInfo.ConnectionDetails.PersistSecurityInfo = true;
-                    string connectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails);
-                    connInfo.ConnectionDetails.ConnectTimeout = originalTimeout;
-                    connInfo.ConnectionDetails.PersistSecurityInfo = originalPersistSecurityInfo;
-
-                    // open a dedicated binding server connection
-                    SqlConnection sqlConn = new SqlConnection(connectionString);                    
-                    sqlConn.Open();
 
                     // populate the binding context to work with the SMO metadata provider
                     ServerConnection serverConn = new ServerConnection(sqlConn);                            

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.cs

@@ -3517,6 +3517,14 @@ namespace Microsoft.SqlTools.ServiceLayer
             }
         }
 
+        public static string ProfilerConnectionNotFound
+        {
+            get
+            {
+                return Keys.GetString(Keys.ProfilerConnectionNotFound);
+            }
+        }
+
         public static string ConnectionServiceListDbErrorNotConnected(string uri)
         {
             return Keys.GetString(Keys.ConnectionServiceListDbErrorNotConnected, uri);
@@ -4945,6 +4953,9 @@ namespace Microsoft.SqlTools.ServiceLayer
             public const string InvalidPathError = "InvalidPathError";
 
 
+            public const string ProfilerConnectionNotFound = "ProfilerConnectionNotFound";
+
+
             private Keys()
             { }
 

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.resx

@@ -1931,4 +1931,8 @@
     <value>Cannot access the specified path on the server: {0}</value>
     <comment></comment>
   </data>
+  <data name="ProfilerConnectionNotFound" xml:space="preserve">
+    <value>Connection not found</value>
+    <comment></comment>
+  </data>
 </root>

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.strings

@@ -849,3 +849,7 @@ ScriptTaskName = scripting
 ############################################################################
 # File Browser Validation Errors
 InvalidPathError = Cannot access the specified path on the server: {0}
+
+############################################################################
+# Profiler
+ProfilerConnectionNotFound = Connection not found

src/Microsoft.SqlTools.ServiceLayer/Localization/sr.xlf

@@ -2250,6 +2250,11 @@
         <target state="new">scripting</target>
         <note></note>
       </trans-unit>
+      <trans-unit id="ProfilerConnectionNotFound">
+        <source>Connection not found</source>
+        <target state="new">Connection not found</target>
+        <note></note>
+      </trans-unit>
       <trans-unit id="BackupPathIsFolderError">
         <source>The provided path specifies a directory but a file path is required: {0}</source>
         <target state="new">The file name specified is also a directory name: {0}</target>

src/Microsoft.SqlTools.ServiceLayer/Metadata/MetadataService.cs

@@ -74,7 +74,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Metadata
                 var metadata = new List<ObjectMetadata>();
                 if (connInfo != null) 
                 {                    
-                    using (SqlConnection sqlConn = OpenMetadataConnection(connInfo))
+                    using (SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo))
                     {
                         ReadMetadata(sqlConn, metadata);
                     }
@@ -129,7 +129,7 @@ namespace Microsoft.SqlTools.ServiceLayer.Metadata
                 ColumnMetadata[] metadata = null;
                 if (connInfo != null) 
                 {
-                    SqlConnection sqlConn = OpenMetadataConnection(connInfo);                    
+                    SqlConnection sqlConn = ConnectionService.OpenSqlConnection(connInfo);                    
                     TableMetadata table = new SmoMetadataFactory().GetObjectMetadata(
                         sqlConn, metadataParams.Schema, 
                         metadataParams.ObjectName, objectType);
@@ -147,35 +147,6 @@ namespace Microsoft.SqlTools.ServiceLayer.Metadata
             }
         }
 
-        /// <summary>
-        /// Create a SqlConnection to use for querying metadata
-        /// </summary>
-        internal static SqlConnection OpenMetadataConnection(ConnectionInfo connInfo)
-        {
-            try
-            {                 
-                // increase the connection timeout to at least 30 seconds and and build connection string
-                // enable PersistSecurityInfo to handle issues in SMO where the connection context is lost in reconnections
-                int? originalTimeout = connInfo.ConnectionDetails.ConnectTimeout;
-                bool? originalPersistSecurityInfo = connInfo.ConnectionDetails.PersistSecurityInfo;
-                connInfo.ConnectionDetails.ConnectTimeout = Math.Max(30, originalTimeout ?? 0);
-                connInfo.ConnectionDetails.PersistSecurityInfo = true;
-                string connectionString = ConnectionService.BuildConnectionString(connInfo.ConnectionDetails);
-                connInfo.ConnectionDetails.ConnectTimeout = originalTimeout;
-                connInfo.ConnectionDetails.PersistSecurityInfo = originalPersistSecurityInfo;
-
-                // open a dedicated binding server connection
-                SqlConnection sqlConn = new SqlConnection(connectionString); 
-                sqlConn.Open();
-                return sqlConn;
-            }
-            catch (Exception)
-            {
-            }
-            
-            return null;
-        }
-
         internal static bool IsSystemDatabase(string database)
         {
             // compare against master for now

src/Microsoft.SqlTools.ServiceLayer/Microsoft.SqlTools.ServiceLayer.csproj

@@ -19,8 +19,7 @@
   </ItemGroup>
   <ItemGroup>
 	<PackageReference Include="System.Data.SqlClient" Version="4.4.0" />
-	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.4" />
+	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.5" />
-	<PackageReference Include="Microsoft.SqlServer.Management.SqlScriptPublishModel" Version="140.2.4" />
   </ItemGroup>
   <ItemGroup>
 	<Compile Include="**\*.cs" />

src/Microsoft.SqlTools.ServiceLayer/Profiler/Contracts/ProfilerEvent.cs

@@ -0,0 +1,78 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Generic;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler.Contracts
+{
+    /// <summary>
+    /// Class that contains data for a single profile event
+    /// </summary>
+    public class ProfilerEvent
+    {
+        /// <summary>
+        /// Initialize a new ProfilerEvent with required parameters
+        /// </summary>
+        public ProfilerEvent(string name, string timestamp)
+        {
+            this.Name = name;
+            this.Timestamp = timestamp;
+            this.Values = new Dictionary<string, string>();
+        }
+
+        /// <summary>
+        /// Profiler event name
+        /// </summary>
+        public string Name { get; private set; }
+
+        /// <summary>
+        /// Profiler event timestamp
+        /// </summary>
+        public string Timestamp { get; private set; }
+
+        /// <summary>
+        /// Profiler event values collection
+        /// </summary>
+        public Dictionary<string, string> Values { get; private set; }
+
+        /// <summary>
+        /// Equals method
+        /// </summary>
+        public bool Equals(ProfilerEvent p)
+        {
+            // if parameter is null return false:
+            if ((object)p == null)
+            {
+                return false;
+            }
+
+            return this.Name == p.Name
+                && this.Timestamp == p.Timestamp
+                && this.Values.Count == p.Values.Count;
+        }
+
+        /// <summary>
+        /// GetHashCode method
+        /// </summary>
+        public override int GetHashCode()
+        {
+            int hashCode = this.GetType().ToString().GetHashCode();
+
+            if (this.Name != null)
+            {
+                hashCode ^= this.Name.GetHashCode();
+            }
+
+            if (this.Timestamp != null)
+            {
+                hashCode ^= this.Timestamp.GetHashCode();
+            }
+
+            hashCode ^= this.Values.Count.GetHashCode();
+
+            return hashCode;
+        }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/Contracts/ProfilerEventsAvailableNotification.cs

@@ -0,0 +1,27 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Generic;
+using Microsoft.SqlTools.Hosting.Protocol.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler.Contracts
+{
+    public class ProfilerEventsAvailableParams
+    {
+        public string SessionId { get; set; }
+
+        public List<ProfilerEvent> Events { get; set; }
+    }
+
+    public class ProfilerEventsAvailableNotification
+    {
+        public static readonly
+            EventType<ProfilerEventsAvailableParams> Type =
+            EventType<ProfilerEventsAvailableParams>.Create("profiler/eventsavailable");
+    }
+}
+
+

src/Microsoft.SqlTools.ServiceLayer/Profiler/Contracts/StartProfilingRequest.cs

@@ -0,0 +1,55 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.Hosting.Protocol.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler.Contracts
+{
+    /// <summary>
+    /// Start Profiling request parameters
+    /// </summary>
+    public class StartProfilingParams : GeneralRequestDetails
+    {
+        public string OwnerUri { get; set; }
+
+        public string TemplateName 
+        {
+            get
+            {
+                return GetOptionValue<string>("templateName");
+            }
+            set
+            {
+                SetOptionValue("templateName", value);
+            }
+        }
+    }
+
+    public class StartProfilingResult
+    {
+        /// <summary>
+        /// Session ID that was started
+        /// </summary>
+        public string SessionId { get; set; }
+
+        public bool Succeeded { get; set; }
+
+        public string ErrorMessage { get; set; }
+    }
+
+    /// <summary>
+    /// Start Profile request type
+    /// </summary>
+    public class StartProfilingRequest
+    {
+        /// <summary>
+        /// Request definition
+        /// </summary>
+        public static readonly
+            RequestType<StartProfilingParams, StartProfilingResult> Type =
+            RequestType<StartProfilingParams, StartProfilingResult>.Create("profiler/start");
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/Contracts/StopProfilingRequest.cs

@@ -0,0 +1,38 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using Microsoft.SqlTools.Hosting.Protocol.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler.Contracts
+{
+    /// <summary>
+    /// Stop Profiling request parameters
+    /// </summary>
+    public class StopProfilingParams
+    {
+        public string SessionId { get; set; }
+    }
+
+    public class StopProfilingResult
+    {
+        public bool Succeeded { get; set; }
+
+        public string ErrorMessage { get; set; }
+    }
+
+    /// <summary>
+    /// Start Profile request type
+    /// </summary>
+    public class StopProfilingRequest
+    {
+        /// <summary>
+        /// Request definition
+        /// </summary>
+        public static readonly
+            RequestType<StopProfilingParams, StopProfilingResult> Type =
+            RequestType<StopProfilingParams, StopProfilingResult>.Create("profiler/stop");
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/IProfilerSessionListener.cs

@@ -0,0 +1,15 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Collections.Generic;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler
+{
+    public interface IProfilerSessionListener
+    {
+        void EventsAvailable(string sessionId, List<ProfilerEvent> events);
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/IProfilerSessionMonitor.cs

@@ -0,0 +1,32 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Xml;
+using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
+using Microsoft.SqlServer.Management.Sdk.Sfc;
+using Microsoft.SqlServer.Management.XEvent;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler
+{
+    /// <summary>
+    /// Profiler session monitor interface
+    /// </summary>
+    public interface IProfilerSessionMonitor
+    {
+        /// <summary>
+        /// Starts monitoring a profiler session
+        /// </summary>
+        bool StartMonitoringSession(ProfilerSession session);
+
+        /// <summary>
+        /// Stops monitoring a profiler session
+        /// </summary>
+        bool StopMonitoringSession(string sessionId);
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/IXEventSession.cs

@@ -0,0 +1,18 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler
+{
+    /// <summary>
+    /// Main class for Profiler Service functionality
+    /// </summary>
+    public interface IXEventSession
+    {
+        /// <summary>
+        /// Reads XEvent XML from the default session target
+        /// </summary>
+        string GetTargetXml();
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/IXEventSessionFactory.cs

@@ -0,0 +1,23 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+
+using Microsoft.SqlServer.Management.Sdk.Sfc;
+using Microsoft.SqlServer.Management.XEvent;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler
+{
+    /// <summary>
+    /// Main class for Profiler Service functionality
+    /// </summary>
+    public interface IXEventSessionFactory
+    {
+        /// <summary>
+        /// Create a new XEvent session
+        /// </summary>
+        IXEventSession CreateXEventSession(ConnectionInfo connInfo);
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/ProfilerService.cs

@@ -0,0 +1,246 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Data.SqlClient;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Xml;
+using Microsoft.SqlServer.Management.Sdk.Sfc;
+using Microsoft.SqlServer.Management.Smo;
+using Microsoft.SqlServer.Management.XEvent;
+using Microsoft.SqlTools.Hosting.Protocol;
+using Microsoft.SqlTools.Hosting.Protocol.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Hosting;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+using Microsoft.SqlTools.Utility;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler
+{
+    /// <summary>
+    /// Main class for Profiler Service functionality
+    /// </summary>
+    public sealed class ProfilerService : IDisposable, IXEventSessionFactory, IProfilerSessionListener
+    {
+        private bool disposed;
+
+        private ConnectionService connectionService = null;
+
+        private ProfilerSessionMonitor monitor = new ProfilerSessionMonitor();
+
+        private static readonly Lazy<ProfilerService> instance = new Lazy<ProfilerService>(() => new ProfilerService());
+
+        /// <summary>
+        /// Construct a new ProfilerService instance with default parameters
+        /// </summary>
+        public ProfilerService()
+        {
+            this.XEventSessionFactory = this;
+        }
+
+        /// <summary>
+        /// Gets the singleton instance object
+        /// </summary>
+        public static ProfilerService Instance
+        {
+            get { return instance.Value; }
+        }
+
+        /// <summary>
+        /// Internal for testing purposes only
+        /// </summary>
+        internal ConnectionService ConnectionServiceInstance
+        {
+            get
+            {
+                if (connectionService == null)
+                {
+                    connectionService = ConnectionService.Instance;
+                }
+                return connectionService;
+            }
+
+            set
+            {
+                connectionService = value;
+            }
+        }
+
+        /// <summary>
+        /// XEvent session factory.  Internal to allow mocking in unit tests.
+        /// </summary>
+        internal IXEventSessionFactory XEventSessionFactory { get; set; }
+
+        /// <summary>
+        /// Session monitor instance
+        /// </summary>
+        internal ProfilerSessionMonitor SessionMonitor
+        {
+            get
+            {
+                return this.monitor;
+            }
+        }
+
+        /// <summary>
+        /// Service host object for sending/receiving requests/events.
+        /// Internal for testing purposes.
+        /// </summary>
+        internal IProtocolEndpoint ServiceHost
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Initializes the Profiler Service instance
+        /// </summary>
+        public void InitializeService(ServiceHost serviceHost)
+        {
+            this.ServiceHost = serviceHost;
+            this.ServiceHost.SetRequestHandler(StartProfilingRequest.Type, HandleStartProfilingRequest);
+            this.ServiceHost.SetRequestHandler(StopProfilingRequest.Type, HandleStopProfilingRequest);
+
+            this.SessionMonitor.AddSessionListener(this);
+        }
+
+        /// <summary>
+        /// Handle request to start a profiling session
+        /// </summary>
+        internal async Task HandleStartProfilingRequest(StartProfilingParams parameters, RequestContext<StartProfilingResult> requestContext)
+        {
+            try
+            {
+                var result = new StartProfilingResult();
+                ConnectionInfo connInfo;
+                ConnectionServiceInstance.TryFindConnection(
+                    parameters.OwnerUri,
+                    out connInfo);
+
+                if (connInfo != null)
+                {
+                    ProfilerSession session = StartSession(connInfo);
+                    result.SessionId = session.SessionId;
+                    result.Succeeded = true;
+                }
+                else
+                {
+                    result.Succeeded = false;
+                    result.ErrorMessage = SR.ProfilerConnectionNotFound;
+                }
+
+                await requestContext.SendResult(result);
+            }
+            catch (Exception e)
+            {
+                await requestContext.SendError(e);
+            }
+        }
+
+        /// <summary>
+        /// Handle request to stop a profiling session
+        /// </summary>
+        internal async Task HandleStopProfilingRequest(StopProfilingParams parameters, RequestContext<StopProfilingResult> requestContext)
+        {
+            try
+            {
+                monitor.StopMonitoringSession(parameters.SessionId);
+                await requestContext.SendResult(new StopProfilingResult
+                {
+                    Succeeded = true
+                });
+            }
+            catch (Exception e)
+            {
+                await requestContext.SendError(e);
+            } 
+        }
+
+        /// <summary>
+        /// Starts a new profiler session for the provided connection
+        /// </summary>
+        internal ProfilerSession StartSession(ConnectionInfo connInfo)
+        {
+            // create a new XEvent session and Profiler session
+            var xeSession = this.XEventSessionFactory.CreateXEventSession(connInfo);
+            var profilerSession = new ProfilerSession()
+            {
+                SessionId = Guid.NewGuid().ToString(),
+                XEventSession = xeSession
+            };
+
+            // start monitoring the profiler session
+            monitor.StartMonitoringSession(profilerSession);
+
+            return profilerSession;
+        }
+
+        /// <summary>
+        /// Create a new XEvent sessions per the IXEventSessionFactory contract
+        /// </summary>
+        public IXEventSession CreateXEventSession(ConnectionInfo connInfo)
+        {
+            var sqlConnection = ConnectionService.OpenSqlConnection(connInfo);
+            SqlStoreConnection connection = new SqlStoreConnection(sqlConnection);
+            Session session = ProfilerService.GetOrCreateSession(connection, "Profiler");
+
+            // create xevent session wrapper
+            return new XEventSession()
+            {
+                Session = session
+            };
+        }
+
+        /// <summary>
+        /// Gets an existing XEvent session or creates one if no matching session exists.
+        /// Also starts the session if it isn't currently running
+        /// </summary>
+        private static Session GetOrCreateSession(SqlStoreConnection connection, string sessionName)
+        {
+            XEStore store = new XEStore(connection);
+            Session session = store.Sessions["Profiler"];
+            // start the session if it isn't already running
+            if (session != null && !session.IsRunning)
+            {
+                session.Start();
+            }
+            return session;
+        }
+
+        /// <summary>
+        /// Callback when profiler events are available
+        /// </summary>
+        public void EventsAvailable(string sessionId, List<ProfilerEvent> events)
+        {
+            // pass the profiler events on to the client
+            this.ServiceHost.SendEvent(
+                ProfilerEventsAvailableNotification.Type,
+                new ProfilerEventsAvailableParams()
+                {
+                    SessionId = sessionId,
+                    Events = events
+                });
+        }
+
+        /// <summary>
+        /// Disposes the Profiler Service
+        /// </summary>
+        public void Dispose()
+        {
+            if (!disposed)
+            {                
+                disposed = true;
+            }
+        }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/ProfilerSession.cs

@@ -0,0 +1,127 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.SqlServer.Management.XEvent;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler
+{
+    /// <summary>
+    /// Profiler session class
+    /// </summary>
+    public class ProfilerSession
+    {
+        private static readonly TimeSpan DefaultPollingDelay = TimeSpan.FromSeconds(1);
+        private object pollingLock = new object();
+        private bool isPolling = false;
+        private DateTime lastPollTime = DateTime.Now.Subtract(DefaultPollingDelay);
+        private TimeSpan pollingDelay = DefaultPollingDelay;
+        private ProfilerEvent lastSeenEvent = null;
+
+        /// <summary>
+        /// Unique ID for the session
+        /// </summary>
+        public string SessionId { get; set; }
+
+        /// <summary>
+        /// Connection to use for the session
+        /// </summary>
+        public ConnectionInfo ConnectionInfo { get; set; }
+
+        /// <summary>
+        /// Underlying XEvent session wrapper
+        /// </summary>
+        public IXEventSession XEventSession { get; set; }
+
+        /// <summary>
+        /// Try to set the session into polling mode if criteria is meet
+        /// </summary>
+        /// <returns>True if session set to polling mode, False otherwise</returns>
+        public bool TryEnterPolling()
+        {
+            lock (this.pollingLock)
+            {
+                if (!this.isPolling && DateTime.Now.Subtract(this.lastPollTime) >= pollingDelay)
+                {
+                    this.isPolling = true;
+                    this.lastPollTime = DateTime.Now;
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Is the session currently being polled
+        /// </summary>
+        public bool IsPolling
+        {
+            get
+            {
+                return this.isPolling;
+            }
+            set
+            {
+                lock (this.pollingLock)
+                {
+                    this.isPolling  = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// The delay between session polls
+        /// </summary>
+        public TimeSpan PollingDelay 
+        {
+            get
+            {
+                return pollingDelay;
+            }
+        }
+
+        /// <summary>
+        /// Filter the event list to not include previously seen events
+        /// </summary>
+        public List<ProfilerEvent> FilterOldEvents(List<ProfilerEvent> events)
+        {
+            if (lastSeenEvent != null)
+            {
+                // find the last event we've previously seen
+                bool foundLastEvent = false;
+                int idx = events.Count;
+                while (--idx >= 0)
+                {
+                    if (events[idx].Equals(lastSeenEvent))
+                    {
+                        foundLastEvent = true;
+                        break;
+                    }
+                }
+
+                // remove all the events we've seen before
+                if (foundLastEvent)
+                {
+                    events.RemoveRange(0, idx + 1);
+                }
+            }
+
+            // save the last event so we know where to clean-up the list from next time
+            if (events.Count > 0)
+            {
+                lastSeenEvent = events.LastOrDefault();
+            }
+
+            return events;
+        }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/ProfilerSessionMonitor.cs

@@ -0,0 +1,201 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Xml;
+using Microsoft.SqlServer.Management.Sdk.Sfc;
+using Microsoft.SqlServer.Management.XEvent;
+using Microsoft.SqlTools.ServiceLayer.Connection.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler
+{
+    /// <summary>
+    /// Classs to monitor active profiler sessions
+    /// </summary>
+    public class ProfilerSessionMonitor : IProfilerSessionMonitor
+    {
+        private const int PollingLoopDelay = 1000;
+
+        private object sessionsLock = new object();
+
+        private object listenersLock = new object();
+
+        private Task processorThread = null;
+
+        private Dictionary<string, ProfilerSession> monitoredSessions = new Dictionary<string, ProfilerSession>();
+
+        private List<IProfilerSessionListener> listeners = new List<IProfilerSessionListener>();
+
+        /// <summary>
+        /// Registers a session event listener to receive a callback when events arrive
+        /// </summary>
+        public void AddSessionListener(IProfilerSessionListener listener)
+        {   
+            lock (this.listenersLock) 
+            {
+                this.listeners.Add(listener);
+            }
+        }
+
+        /// <summary>
+        /// Start monitoring the provided sessions
+        /// </summary>
+        public bool StartMonitoringSession(ProfilerSession session)
+        {
+            lock (this.sessionsLock)
+            {
+                // start the monitoring thread 
+                if (this.processorThread == null)
+                {
+                    this.processorThread = Task.Factory.StartNew(ProcessSessions);;
+                }
+
+                if (!this.monitoredSessions.ContainsKey(session.SessionId))
+                {
+                    this.monitoredSessions.Add(session.SessionId, session);
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Stop monitoring the session specified by the sessionId
+        /// </summary>
+        public bool StopMonitoringSession(string sessionId)
+        {
+            lock (this.sessionsLock)
+            {
+                if (this.monitoredSessions.ContainsKey(sessionId))
+                {
+                    ProfilerSession session;
+                    return this.monitoredSessions.Remove(sessionId, out session);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// The core queue processing method
+        /// </summary>
+        /// <param name="state"></param>
+        private void ProcessSessions()
+        {    
+            while (true)
+            {
+                lock (this.sessionsLock)
+                {
+                    foreach (var session in this.monitoredSessions.Values)
+                    {
+                        ProcessSession(session);
+                    }
+                }
+
+                Thread.Sleep(PollingLoopDelay);
+            }
+        }
+
+        /// <summary>
+        /// Process a session for new XEvents if it meets the polling criteria
+        /// </summary>
+        private void ProcessSession(ProfilerSession session)
+        {
+            if (session.TryEnterPolling())
+            {
+                Task.Factory.StartNew(() => 
+                {
+                    var events = PollSession(session);
+                    if (events.Count > 0)
+                    {
+                        SendEventsToListeners(session.SessionId, events);
+                    }
+                });
+            }
+        }
+
+        private List<ProfilerEvent> PollSession(ProfilerSession session)
+        {
+            var events = new List<ProfilerEvent>();
+            try
+            {
+                if (session == null || session.XEventSession == null)
+                {
+                    return events;
+                }
+
+                var targetXml = session.XEventSession.GetTargetXml();
+
+                XmlDocument xmlDoc = new XmlDocument();
+                xmlDoc.LoadXml(targetXml);
+
+                var nodes = xmlDoc.DocumentElement.GetElementsByTagName("event");
+                foreach (XmlNode node in nodes)
+                {
+                    var profilerEvent = ParseProfilerEvent(node);
+                    if (profilerEvent != null)
+                    {
+                        events.Add(profilerEvent);
+                    }
+                }
+            }
+            finally
+            {
+                session.IsPolling = false;
+            }
+
+            return session.FilterOldEvents(events);
+        }
+
+        /// <summary>
+        /// Notify listeners when new profiler events are available
+        /// </summary>
+        private void SendEventsToListeners(string sessionId, List<ProfilerEvent> events)
+        {
+            lock (listenersLock)
+            {
+                foreach (var listener in this.listeners)
+                {
+                    listener.EventsAvailable(sessionId, events);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parse a single event node from XEvent XML
+        /// </summary>
+        private ProfilerEvent ParseProfilerEvent(XmlNode node)
+        {
+            var name = node.Attributes["name"];
+            var timestamp = node.Attributes["timestamp"];
+
+            var profilerEvent = new ProfilerEvent(name.InnerText, timestamp.InnerText);
+    
+            foreach (XmlNode childNode in node.ChildNodes)
+            {
+                var childName = childNode.Attributes["name"];
+                XmlNode typeNode = childNode.SelectSingleNode("type");
+                var typeName = typeNode.Attributes["name"];
+                XmlNode valueNode = childNode.SelectSingleNode("value");
+
+                if (!profilerEvent.Values.ContainsKey(childName.InnerText))
+                {
+                    profilerEvent.Values.Add(childName.InnerText, valueNode.InnerText);
+                }
+            }
+
+            return profilerEvent;
+        }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Profiler/XEventSession.cs

@@ -0,0 +1,29 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System.Linq;
+using Microsoft.SqlServer.Management.XEvent;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+
+namespace Microsoft.SqlTools.ServiceLayer.Profiler
+{
+    public class XEventSession : IXEventSession
+    {
+        public Session Session { get; set; }
+
+        public string GetTargetXml()
+        {
+            if (this.Session == null)
+            {
+                return string.Empty;
+            }
+
+            // try to read events from the first target
+            Target defaultTarget = this.Session.Targets.FirstOrDefault();
+            return defaultTarget != null ? defaultTarget.GetTargetData() : string.Empty;
+        }
+    }
+}

src/Microsoft.SqlTools.ServiceLayer/Scripting/ScriptingService.cs

@@ -213,12 +213,12 @@ namespace Microsoft.SqlTools.ServiceLayer.Scripting
         {
             if (!disposed)
             {
+                disposed = true;
+                
                 foreach (ScriptingScriptOperation operation in this.ActiveOperations.Values)
                 {
                     operation.Dispose();
                 }
-
-                disposed = true;
             }
         }
 

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/DisasterRecovery/BackupServiceTests.cs

@@ -12,6 +12,7 @@ using Microsoft.SqlServer.Management.Smo;
 using Microsoft.SqlTools.Hosting.Protocol;
 using Microsoft.SqlTools.ServiceLayer.Admin;
 using Microsoft.SqlTools.ServiceLayer.Admin.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Connection;
 using Microsoft.SqlTools.ServiceLayer.DisasterRecovery;
 using Microsoft.SqlTools.ServiceLayer.DisasterRecovery.Contracts;
 using Microsoft.SqlTools.ServiceLayer.FileBrowser;
@@ -77,7 +78,7 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
             SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);
             var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
             DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-            SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+            SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
 
             string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);
 
@@ -102,7 +103,7 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
             SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);
             var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
             DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-            SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+            SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
             string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);
 
             BackupInfo backupInfo = CreateDefaultBackupInfo(databaseName,
@@ -135,7 +136,7 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
             SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);
             var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
             DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-            SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+            SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
             string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);
 
             string certificateName = CreateCertificate(testDb);
@@ -187,7 +188,7 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
             SqlTestDb testDb = SqlTestDb.CreateNew(TestServerType.OnPrem, false, databaseName);
             var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
             DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-            SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+            SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
             string backupPath = GetDefaultBackupFullPath(service, databaseName, helper.DataContainer, sqlConn);
 
             string certificateName = CreateCertificate(testDb);
@@ -239,7 +240,7 @@ CREATE CERTIFICATE {1} WITH SUBJECT = 'Backup Encryption Certificate'; ";
             // Initialize backup service
             var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName);
             DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-            SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+            SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
             DisasterRecoveryService disasterRecoveryService = new DisasterRecoveryService();
             BackupConfigInfo backupConfigInfo = disasterRecoveryService.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
 

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/DisasterRecovery/DisasterRecoveryFileValidatorTests.cs

@@ -3,15 +3,16 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
+using System;
 using System.Data.SqlClient;
 using System.IO;
 using Microsoft.SqlTools.ServiceLayer.Admin;
+using Microsoft.SqlTools.ServiceLayer.Connection;
 using Microsoft.SqlTools.ServiceLayer.DisasterRecovery;
 using Microsoft.SqlTools.ServiceLayer.DisasterRecovery.Contracts;
 using Microsoft.SqlTools.ServiceLayer.FileBrowser;
 using Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility;
 using Xunit;
-using System;
 
 namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
 {
@@ -25,7 +26,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
         {
             var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master");
             DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-            SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+            SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
             string backupPath = Path.Combine(GetDefaultBackupFolderPath(helper.DataContainer, sqlConn), "master.bak");
 
             string message;
@@ -45,7 +46,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
         {
             var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master");
             DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-            SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+            SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
             string backupPath = GetDefaultBackupFolderPath(helper.DataContainer, sqlConn);
 
             bool isFolder;

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/DisasterRecovery/RestoreDatabaseServiceTests.cs

@@ -606,7 +606,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
                 // Initialize backup service
                 var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo(databaseName, queryTempFile.FilePath);
                 DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-                SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+                SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
                 BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
 
                 query = $"create table [test].[{tableNames[0]}] (c1 int)";
@@ -661,9 +661,9 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.DisasterRecovery
 
                 // Initialize backup service
                 DatabaseTaskHelper helper = AdminService.CreateDatabaseTaskHelper(liveConnection.ConnectionInfo, databaseExists: true);
-                SqlConnection sqlConn = DisasterRecoveryService.GetSqlConnection(liveConnection.ConnectionInfo);
+                SqlConnection sqlConn = ConnectionService.OpenSqlConnection(liveConnection.ConnectionInfo);
 
-                // Get default backup path
+                // Get default backup pathS
                 BackupConfigInfo backupConfigInfo = DisasterRecoveryService.Instance.GetBackupConfigInfo(helper.DataContainer, sqlConn, sqlConn.Database);
                 string backupPath = Path.Combine(backupConfigInfo.DefaultBackupFolder, testDb.DatabaseName + ".bak");
 

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/Metadata/MetadataServiceTests.cs

@@ -3,17 +3,18 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 //
 
-using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts;
+using System;
-using Xunit;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Threading.Tasks;
+using Microsoft.SqlTools.Hosting.Protocol;
+using Microsoft.SqlTools.ServiceLayer.Connection;
 using Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility;
 using Microsoft.SqlTools.ServiceLayer.Metadata;
-using System.Collections.Generic;
 using Microsoft.SqlTools.ServiceLayer.Metadata.Contracts;
-using System.Data.SqlClient;
+using Microsoft.SqlTools.ServiceLayer.Workspace.Contracts;
-using System;
 using Moq;
-using Microsoft.SqlTools.Hosting.Protocol;
+using Xunit;
-using System.Threading.Tasks;
 
 namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Metadata
 {
@@ -71,7 +72,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Metadata
             this.testTableName += new Random().Next(1000000, 9999999).ToString();
 
             var result = GetLiveAutoCompleteTestObjects();
-            var sqlConn = MetadataService.OpenMetadataConnection(result.ConnectionInfo);
+            var sqlConn = ConnectionService.OpenSqlConnection(result.ConnectionInfo);
             Assert.NotNull(sqlConn);
 
             CreateTestTable(sqlConn);
@@ -101,7 +102,7 @@ namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Metadata
             this.testTableName += new Random().Next(1000000, 9999999).ToString();
                    
             var result = GetLiveAutoCompleteTestObjects();
-            var sqlConn = MetadataService.OpenMetadataConnection(result.ConnectionInfo);
+            var sqlConn = ConnectionService.OpenSqlConnection(result.ConnectionInfo);
 
             CreateTestTable(sqlConn);
 

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/Microsoft.SqlTools.ServiceLayer.IntegrationTests.csproj

@@ -31,7 +31,7 @@
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
 	  <PackageReference Include="System.Data.SqlClient" Version="4.4.0" />
-	  <PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.4" />
+	  <PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.5" />
   </ItemGroup>
   <ItemGroup>
     <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />

test/Microsoft.SqlTools.ServiceLayer.IntegrationTests/Profiler/ProfilerServiceTests.cs

@@ -0,0 +1,90 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.SqlServer.Management.Smo;
+using Microsoft.SqlServer.Management.XEvent;
+using Microsoft.SqlTools.Hosting.Protocol;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.IntegrationTests.Utility;
+using Microsoft.SqlTools.ServiceLayer.Profiler;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+using Microsoft.SqlTools.ServiceLayer.Test.Common;
+using Moq;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.IntegrationTests.Profiler
+{
+    public class ProfilerServiceTests
+    {
+        /// <summary>
+        /// Verify that a start profiling request starts a profiling session
+        /// </summary>
+        [Fact]
+        public async Task TestHandleStartAndStopProfilingRequests()
+        {
+            using (SelfCleaningTempFile queryTempFile = new SelfCleaningTempFile())
+            {
+                var connectionResult = await LiveConnectionHelper.InitLiveConnectionInfoAsync("master", queryTempFile.FilePath);
+
+                ProfilerService profilerService = new ProfilerService();
+
+                // start a new session
+                var startParams = new StartProfilingParams();
+                startParams.OwnerUri = connectionResult.ConnectionInfo.OwnerUri;
+                startParams.TemplateName = "Standard";
+
+                string sessionId = null;
+                var startContext = new Mock<RequestContext<StartProfilingResult>>();
+                startContext.Setup(rc => rc.SendResult(It.IsAny<StartProfilingResult>()))
+                    .Returns<StartProfilingResult>((result) => 
+                    {
+                        // capture the session id for sending the stop message
+                        sessionId = result.SessionId;
+                        return Task.FromResult(0);
+                    });
+
+                await profilerService.HandleStartProfilingRequest(startParams, startContext.Object);
+
+                startContext.VerifyAll();
+
+                // wait a bit for the session monitoring to initialize
+                Thread.Sleep(TimeSpan.FromHours(1));
+
+                // stop the session
+                var stopParams = new StopProfilingParams()
+                {
+                    SessionId = sessionId
+                };
+
+                var stopContext = new Mock<RequestContext<StopProfilingResult>>();
+                stopContext.Setup(rc => rc.SendResult(It.IsAny<StopProfilingResult>()))
+                    .Returns(Task.FromResult(0));
+
+                await profilerService.HandleStopProfilingRequest(stopParams, stopContext.Object);
+
+                stopContext.VerifyAll();
+            }           
+        }
+
+        /// <summary>
+        /// Verify  the profiler service XEvent session factory
+        /// </summary>
+        [Fact]
+        public void TestCreateXEventSession()
+        {
+            var liveConnection = LiveConnectionHelper.InitLiveConnectionInfo("master");
+            ProfilerService profilerService = new ProfilerService();
+            IXEventSession xeSession = profilerService.CreateXEventSession(liveConnection.ConnectionInfo);
+            Assert.NotNull(xeSession);
+            Assert.NotNull(xeSession.GetTargetXml());
+        }
+    }
+}

test/Microsoft.SqlTools.ServiceLayer.Test.Common/Microsoft.SqlTools.ServiceLayer.Test.Common.csproj

@@ -12,7 +12,7 @@
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
 	<PackageReference Include="System.Data.SqlClient" Version="4.4.0" />
-	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.4" />
+	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.5" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Scripts/CreateTestDatabaseObjects.sql" />

test/Microsoft.SqlTools.ServiceLayer.TestDriver/Microsoft.SqlTools.ServiceLayer.TestDriver.csproj

@@ -12,8 +12,7 @@
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
 	<PackageReference Include="System.Data.SqlClient" Version="4.4.0" />
-	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.4" />
+	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.5" />
-	<PackageReference Include="Microsoft.SqlServer.Management.SqlScriptPublishModel" Version="140.2.4" />
   </ItemGroup>
   <ItemGroup>
 	<ProjectReference Include="../../src/Microsoft.SqlTools.Hosting/Microsoft.SqlTools.Hosting.csproj" />

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Microsoft.SqlTools.ServiceLayer.UnitTests.csproj

@@ -13,7 +13,7 @@
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
 	  <PackageReference Include="System.Data.SqlClient" Version="4.4.0" />
-  	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.4" />
+  	<PackageReference Include="Microsoft.SqlServer.Smo" Version="140.2.5" />
   </ItemGroup>
   <ItemGroup> 	
 	<Reference Include="Newtonsoft.Json">

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Profiler/ProfilerServiceTests.cs

@@ -0,0 +1,68 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.SqlServer.Management.XEvent;
+using Microsoft.SqlTools.Hosting.Protocol;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.Profiler;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+using Microsoft.SqlTools.ServiceLayer.UnitTests.Utility;
+using Moq;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Profiler
+{
+    /// <summary>
+    /// Unit tests for ProfilerService
+    /// </summary>
+    public class ProfilerServiceTests
+    {   
+        /// <summary>
+        /// Test starting a profiling session and receiving event callback
+        /// </summary>
+        /// <returns></returns>
+        [Fact]
+        public async Task TestStartProfilingRequest()
+        {
+            string sessionId = null;
+            string testUri = "profiler_uri";
+            var requestContext = new Mock<RequestContext<StartProfilingResult>>();
+            requestContext.Setup(rc => rc.SendResult(It.IsAny<StartProfilingResult>()))
+                .Returns<StartProfilingResult>((result) => 
+                {
+                    // capture the session id for sending the stop message
+                    sessionId = result.SessionId;
+                    return Task.FromResult(0);
+                });
+
+            var sessionListener = new TestSessionListener();
+
+            var profilerService = new ProfilerService();
+            profilerService.SessionMonitor.AddSessionListener(sessionListener);
+            profilerService.ConnectionServiceInstance = TestObjects.GetTestConnectionService();
+            ConnectionInfo connectionInfo = TestObjects.GetTestConnectionInfo();
+            profilerService.ConnectionServiceInstance.OwnerToConnectionMap.Add(testUri, connectionInfo);
+            profilerService.XEventSessionFactory = new TestXEventSessionFactory();
+
+            var requestParams = new StartProfilingParams();
+            requestParams.OwnerUri = testUri;
+            requestParams.TemplateName = "Standard";
+
+            await profilerService.HandleStartProfilingRequest(requestParams, requestContext.Object);
+
+            // wait a bit for profile sessions to be polled
+            Thread.Sleep(500);
+
+            requestContext.VerifyAll();
+
+            Assert.Equal(sessionListener.PreviousSessionId, sessionId);
+            Assert.Equal(sessionListener.PreviousEvents.Count, 1);
+        }
+    }
+}

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Profiler/ProfilerSessionTests.cs

@@ -0,0 +1,87 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Threading;
+using Microsoft.SqlTools.ServiceLayer.Profiler;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Profiler
+{
+    /// <summary>
+    /// Tests for ProfilerSession class
+    /// </summary>
+    public class ProfilerSessionTests
+    {   
+        /// <summary>
+        /// Test the FilterOldEvents method
+        /// </summary>
+        [Fact]
+        public void TestFilterOldEvents()
+        {
+            // create a profiler session and get some test events
+            var profilerSession = new ProfilerSession();
+            var profilerEvents = ProfilerTestObjects.TestProfilerEvents;
+            
+            // filter old events shouldn't filter any new events
+            var newProfilerEvents = profilerSession.FilterOldEvents(profilerEvents);
+            Assert.Equal(profilerEvents.Count, newProfilerEvents.Count);
+
+            // filter should now filter all the events since they've been seen before
+            newProfilerEvents = profilerSession.FilterOldEvents(profilerEvents);
+            Assert.Equal(newProfilerEvents.Count, 0);
+
+            // add a new event
+            var newEvent = new ProfilerEvent("new event", "1/1/2017");
+            profilerEvents.Add(newEvent);
+
+            // verify we only have the new event when reprocessing the event list
+            newProfilerEvents = profilerSession.FilterOldEvents(profilerEvents);
+            Assert.Equal(newProfilerEvents.Count, 1);
+            Assert.True(newProfilerEvents[0].Equals(newEvent));
+
+            // process whole list again and verify nothing new is available
+            newProfilerEvents = profilerSession.FilterOldEvents(profilerEvents);
+            Assert.Equal(newProfilerEvents.Count, 0);
+        }
+
+        /// <summary>
+        /// Test the TryEnterPolling method
+        /// </summary>
+        [Fact]
+        public void TestTryEnterPolling()
+        {
+            DateTime startTime = DateTime.Now;
+
+            // create new profiler session
+            var profilerSession = new ProfilerSession();
+            
+            // enter the polling block
+            Assert.True(profilerSession.TryEnterPolling());
+            Assert.True(profilerSession.IsPolling);
+
+            // verify we can't enter again
+            Assert.False(profilerSession.TryEnterPolling());
+
+            // set polling to false to exit polling block
+            profilerSession.IsPolling = false;
+
+            bool outsideDelay = DateTime.Now.Subtract(startTime) >= profilerSession.PollingDelay;
+
+            // verify we can only enter again if we're outside polling delay interval
+            Assert.Equal(profilerSession.TryEnterPolling(), outsideDelay);
+
+            // reset IsPolling in case the delay has elasped on slow machine or while debugging
+            profilerSession.IsPolling = false;
+
+            // wait for the polling delay to elapse
+            Thread.Sleep(profilerSession.PollingDelay);
+
+            // verify we can enter the polling block again
+            Assert.True(profilerSession.TryEnterPolling());
+        }
+    }
+}

test/Microsoft.SqlTools.ServiceLayer.UnitTests/Profiler/ProfilerTestObjects.cs

@@ -0,0 +1,204 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.SqlServer.Management.XEvent;
+using Microsoft.SqlTools.Hosting.Protocol;
+using Microsoft.SqlTools.ServiceLayer.Connection;
+using Microsoft.SqlTools.ServiceLayer.Profiler;
+using Microsoft.SqlTools.ServiceLayer.Profiler.Contracts;
+using Microsoft.SqlTools.ServiceLayer.UnitTests.Utility;
+using Moq;
+using Xunit;
+
+namespace Microsoft.SqlTools.ServiceLayer.UnitTests.Profiler
+{
+    public static class ProfilerTestObjects
+    {
+        public static List<ProfilerEvent> TestProfilerEvents
+        {
+            get
+            {
+                return new List<ProfilerEvent>
+                {
+                    new ProfilerEvent("event1", "1/1/2017"),
+                    new ProfilerEvent("event2", "1/2/2017"),
+                    new ProfilerEvent("event3", "1/3/2017")
+                };
+            }
+        }
+    }
+
+    public class TestSessionListener : IProfilerSessionListener
+    {
+        public string PreviousSessionId { get; set; }
+
+        public List<ProfilerEvent> PreviousEvents { get; set; }
+
+        public void EventsAvailable(string sessionId, List<ProfilerEvent> events)
+        {
+            this.PreviousSessionId = sessionId;
+            this.PreviousEvents = events;
+        }
+    }
+
+    public class TestXEventSession : IXEventSession
+    {
+        private string testXEventXml = 
+            "<RingBufferTarget truncated=\"0\" processingTime=\"3\" totalEventsProcessed=\"1\" eventCount=\"1\" droppedCount=\"0\" memoryUsed=\"47996\">" + 
+            "	<event name=\"existing_connection\" package=\"sqlserver\" timestamp=\"2017-09-08T07:46:53.579Z\">" + 
+            "		<data name=\"session_id\">" + 
+            "			<type name=\"int16\" package=\"package0\"></type>" + 
+            "			<value>51</value>" + 
+            "		</data>" + 
+            "		<data name=\"is_dac\">" + 
+            "			<type name=\"boolean\" package=\"package0\"></type>" + 
+            "			<value>false</value>" + 
+            "		</data>" + 
+            "		<data name=\"database_id\">" + 
+            "			<type name=\"uint32\" package=\"package0\"></type>" + 
+            "			<value>1</value>" + 
+            "		</data>" + 
+            "		<data name=\"packet_size\">" + 
+            "			<type name=\"uint32\" package=\"package0\"></type>" + 
+            "			<value>4096</value>" + 
+            "		</data>" + 
+            "		<data name=\"transaction_count\">" + 
+            "			<type name=\"uint32\" package=\"package0\"></type>" + 
+            "			<value>0</value>" + 
+            "		</data>" + 
+            "		<data name=\"group_id\">" + 
+            "			<type name=\"uint32\" package=\"package0\"></type>" + 
+            "			<value>2</value>" + 
+            "		</data>" + 
+            "		<data name=\"duration\">" + 
+            "			<type name=\"uint64\" package=\"package0\"></type>" + 
+            "			<value>191053000</value>" + 
+            "		</data>" + 
+            "		<data name=\"client_pid\">" + 
+            "			<type name=\"uint32\" package=\"package0\"></type>" + 
+            "			<value>4680</value>" + 
+            "		</data>" + 
+            "		<data name=\"options\">" + 
+            "			<type name=\"binary_data\" package=\"package0\"></type>" + 
+            "			<value>2000002838f4010000000000</value>" + 
+            "		</data>" + 
+            "		<data name=\"options_text\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value>" + 
+            "				<![CDATA[-- network protocol: LPC" + 
+            "set quoted_identifier on" + 
+            "set arithabort off" + 
+            "set numeric_roundabort off" + 
+            "set ansi_warnings on" + 
+            "set ansi_padding on" + 
+            "set ansi_nulls on" + 
+            "set concat_null_yields_null on" + 
+            "set cursor_close_on_commit off" + 
+            "set implicit_transactions off" + 
+            "set language us_english" + 
+            "set dateformat mdy" + 
+            "set datefirst 7" + 
+            "set transaction isolation level read committed" + 
+            "]]>" + 
+            "			</value>" + 
+            "		</data>" + 
+            "		<data name=\"started_event_session_name\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[Profiler]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"database_name\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"client_app_name\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[Microsoft SQL Server Management Studio]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"client_hostname\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[KARLBURTRAMC189]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"nt_domain\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"nt_user\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"session_nt_domain\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"session_nt_user\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"server_principal_name\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[sa]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"server_principal_sid\">" + 
+            "			<type name=\"binary_data\" package=\"package0\"></type>" + 
+            "			<value>01</value>" + 
+            "		</data>" + 
+            "		<data name=\"session_server_principal_name\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[sa]]></value>" + 
+            "		</data>" + 
+            "		<data name=\"session_server_principal_sid\">" + 
+            "			<type name=\"binary_data\" package=\"package0\"></type>" + 
+            "			<value>01</value>" + 
+            "		</data>" + 
+            "		<action name=\"session_id\" package=\"sqlserver\">" + 
+            "			<type name=\"uint16\" package=\"package0\"></type>" + 
+            "			<value>56</value>" + 
+            "		</action>" + 
+            "		<action name=\"server_principal_name\" package=\"sqlserver\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[sa]]></value>" + 
+            "		</action>" + 
+            "		<action name=\"nt_username\" package=\"sqlserver\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[]]></value>" + 
+            "		</action>" + 
+            "		<action name=\"client_pid\" package=\"sqlserver\">" + 
+            "			<type name=\"uint32\" package=\"package0\"></type>" + 
+            "			<value>930958063</value>" + 
+            "		</action>" + 
+            "		<action name=\"client_app_name\" package=\"sqlserver\">" + 
+            "			<type name=\"unicode_string\" package=\"package0\"></type>" + 
+            "			<value><![CDATA[Core .Net SqlClient Data Provider]]></value>" + 
+            "		</action>" + 
+            "		<action name=\"attach_activity_id_xfer\" package=\"package0\">" + 
+            "			<type name=\"activity_id_xfer\" package=\"package0\"></type>" + 
+            "			<value>A2873402-C433-4D1F-94C4-9CA99749453E-0</value>" + 
+            "		</action>" + 
+            "		<action name=\"attach_activity_id\" package=\"package0\">" + 
+            "			<type name=\"activity_id\" package=\"package0\"></type>" + 
+            "			<value>770C3538-EC3F-4A27-86A9-31A2FC777DBC-1</value>" + 
+            "		</action>" + 
+            "	</event>" + 
+            "</RingBufferTarget>";
+
+        public string GetTargetXml()
+        {
+            return testXEventXml;
+        }
+    }
+
+    public class TestXEventSessionFactory : IXEventSessionFactory
+    {
+        public IXEventSession CreateXEventSession(ConnectionInfo connInfo)
+        {
+            return new TestXEventSession();
+        }
+    }
+}