diff --git a/Snowflake.Data.Tests/App.config b/Snowflake.Data.Tests/App.config
index 62a7928d6..a7920fad2 100755
--- a/Snowflake.Data.Tests/App.config
+++ b/Snowflake.Data.Tests/App.config
@@ -6,7 +6,7 @@ Copyright (c) 2012-2017 Snowflake Computing Inc. All rights reserved.
   <configSections>
     <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
   </configSections>
-  
+
   <log4net>
     <appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender">
       <file type="log4net.Util.PatternString" value="test_%property{framework}.log" />
@@ -29,7 +29,7 @@ Copyright (c) 2012-2017 Snowflake Computing Inc. All rights reserved.
     <root>
       <level value="ALL" />
       <appender-ref ref="RollingFileAppender" />
-    </root>    
+    </root>
     <root>
       <level value="WARN" />
       <appender-ref ref="ConsoleAppender" />
@@ -39,12 +39,12 @@ Copyright (c) 2012-2017 Snowflake Computing Inc. All rights reserved.
   <!-- used in SFDbFactoryIT.cs to test registering DbProviderFactoryClass -->
   <system.data>
     <DbProviderFactories>
-      <add name="Snowflake" invariant="Snowflake.Data" 
-           type="Snowflake.Data.Client.SnowflakeDbFactory, Snowflake.Data, Culture=neutral, PublicKeyToken=null" 
+      <add name="Snowflake" invariant="Snowflake.Data"
+           type="Snowflake.Data.Client.SnowflakeDbFactory, Snowflake.Data, Culture=neutral, PublicKeyToken=null"
            description="Snowflake Provider" />
     </DbProviderFactories>
   </system.data>
-  
+
   <!-- 
   =========== Enable Network debug log ===============
   <system.diagnostics>
diff --git a/Snowflake.Data.Tests/IntegrationTests/PoolConfigRestorer.cs b/Snowflake.Data.Tests/IntegrationTests/PoolConfigRestorer.cs
new file mode 100644
index 000000000..0682df151
--- /dev/null
+++ b/Snowflake.Data.Tests/IntegrationTests/PoolConfigRestorer.cs
@@ -0,0 +1,24 @@
+using Snowflake.Data.Client;
+
+namespace Snowflake.Data.Tests.IntegrationTests
+{
+    class PoolConfigRestorer {
+        private readonly bool _pooling;
+        private readonly long _timeout;
+        private readonly int _maxPoolSize;
+
+        public PoolConfigRestorer()
+        {
+            _maxPoolSize = SnowflakeDbConnectionPool.GetMaxPoolSize();
+            _timeout = SnowflakeDbConnectionPool.GetTimeout();
+            _pooling = SnowflakeDbConnectionPool.GetPooling();
+        }
+
+        public void Reset()
+        {
+            SnowflakeDbConnectionPool.SetMaxPoolSize(_maxPoolSize);
+            SnowflakeDbConnectionPool.SetTimeout(_timeout);
+            SnowflakeDbConnectionPool.SetPooling(_pooling);
+        }
+    }
+}
diff --git a/Snowflake.Data.Tests/IntegrationTests/SFConnectionIT.cs b/Snowflake.Data.Tests/IntegrationTests/SFConnectionIT.cs
index 40bc46acc..bd3451a7d 100644
--- a/Snowflake.Data.Tests/IntegrationTests/SFConnectionIT.cs
+++ b/Snowflake.Data.Tests/IntegrationTests/SFConnectionIT.cs
@@ -18,17 +18,29 @@ namespace Snowflake.Data.Tests.IntegrationTests
     using Snowflake.Data.Tests.Mock;
     using System.Runtime.InteropServices;
 
-    [TestFixture]
+    [TestFixture, NonParallelizable]
     class SFConnectionIT : SFBaseTest
     {
         private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<SFConnectionIT>();
+        private static readonly PoolConfigRestorer s_previousPoolConfig = new PoolConfigRestorer();
+
+        [SetUp]
+        public void BeforeTest()
+        {
+            s_previousPoolConfig.Reset();
+            SnowflakeDbConnectionPool.ClearAllPools();
+        }
 
+        [TearDown]
+        public void AfterTest()
+        {
+            s_previousPoolConfig.Reset();
+        }
         [Test]
         public void TestBasicConnection()
         {
             using (IDbConnection conn = new SnowflakeDbConnection())
             {
-                SnowflakeDbConnectionPool.SetPooling(false);
                 conn.ConnectionString = ConnectionString;
                 conn.Open();
                 Assert.AreEqual(ConnectionState.Open, conn.State);
@@ -137,7 +149,6 @@ public void TestIncorrectUserOrPasswordBasicConnection()
         [TestCase(false)]
         public void TestConnectionIsNotMarkedAsOpenWhenWasNotCorrectlyOpenedBefore(bool explicitClose)
         {
-            SnowflakeDbConnectionPool.SetPooling(true);
             for (int i = 0; i < 2; ++i)
             {
                 s_logger.Debug($"Running try #{i}");
@@ -1889,9 +1900,9 @@ public void TestCloseAsync()
         [Test, NonParallelizable]
         public void TestCloseAsyncFailure()
         {
+            SnowflakeDbConnectionPool.SetPooling(false);
             using (var conn = new MockSnowflakeDbConnection(new MockCloseSessionException()))
             {
-                SnowflakeDbConnectionPool.SetPooling(false);
                 conn.ConnectionString = ConnectionString;
                 Assert.AreEqual(conn.State, ConnectionState.Closed);
                 Task task = null;
diff --git a/Snowflake.Data.Tests/IntegrationTests/SFConnectionPoolT.cs b/Snowflake.Data.Tests/IntegrationTests/SFConnectionPoolT.cs
index 005db6605..6f858d7cf 100644
--- a/Snowflake.Data.Tests/IntegrationTests/SFConnectionPoolT.cs
+++ b/Snowflake.Data.Tests/IntegrationTests/SFConnectionPoolT.cs
@@ -15,37 +15,16 @@ namespace Snowflake.Data.Tests.IntegrationTests
     using Snowflake.Data.Tests.Mock;
     using System.Data.Common;
     using Moq;
-    
-    class PoolConfig {
-        private readonly bool _pooling;
-        private readonly long _timeout;
-        private readonly int _maxPoolSize;
 
-        public PoolConfig()
-        {
-            _maxPoolSize = SnowflakeDbConnectionPool.GetMaxPoolSize();
-            _timeout = SnowflakeDbConnectionPool.GetTimeout();
-            _pooling = SnowflakeDbConnectionPool.GetPooling();
-        }
-
-        public void Reset()
-        {
-            SnowflakeDbConnectionPool.SetMaxPoolSize(_maxPoolSize);
-            SnowflakeDbConnectionPool.SetTimeout(_timeout);
-            SnowflakeDbConnectionPool.SetPooling(_pooling);
-        }
-    }
-    
     [TestFixture, NonParallelizable]
     class SFConnectionPoolT : SFBaseTest
     {
-        private static SFLogger logger = SFLoggerFactory.GetLogger<SFConnectionPoolT>();
-        private static readonly PoolConfig previousPoolConfig = new PoolConfig();
+        private static readonly PoolConfigRestorer s_previousPoolConfig = new PoolConfigRestorer();
 
         [SetUp]
         public void BeforeTest()
         {
-            previousPoolConfig.Reset();
+            s_previousPoolConfig.Reset();
             SnowflakeDbConnectionPool.SetPooling(true);
             SnowflakeDbConnectionPool.ClearAllPools();
         }
@@ -53,7 +32,7 @@ public void BeforeTest()
         [TearDown]
         public void AfterTest()
         {
-            previousPoolConfig.Reset();
+            s_previousPoolConfig.Reset();
         }
 
         [OneTimeTearDown]
@@ -435,12 +414,12 @@ public void TestConnectionPoolTurnOff()
     class SFConnectionPoolITAsync : SFBaseTestAsync
     {
         private static SFLogger logger = SFLoggerFactory.GetLogger<SFConnectionPoolITAsync>();
-        private static readonly PoolConfig previousPoolConfig = new PoolConfig();
+        private static readonly PoolConfigRestorer s_previousPoolConfigRestorer = new PoolConfigRestorer();
 
         [SetUp]
         public void BeforeTest()
         {
-            previousPoolConfig.Reset();
+            s_previousPoolConfigRestorer.Reset();
             SnowflakeDbConnectionPool.SetPooling(true);
             SnowflakeDbConnectionPool.ClearAllPools();
         }
@@ -448,7 +427,7 @@ public void BeforeTest()
         [TearDown]
         public void AfterTest()
         {
-            previousPoolConfig.Reset();
+            s_previousPoolConfigRestorer.Reset();
         }
         
         [OneTimeTearDown]
diff --git a/Snowflake.Data.Tests/IntegrationTests/SFDbCommandIT.cs b/Snowflake.Data.Tests/IntegrationTests/SFDbCommandIT.cs
index 98e9af7c1..8532b3bb0 100755
--- a/Snowflake.Data.Tests/IntegrationTests/SFDbCommandIT.cs
+++ b/Snowflake.Data.Tests/IntegrationTests/SFDbCommandIT.cs
@@ -229,9 +229,6 @@ public void TestSimpleLargeResultSet()
         }
 
 
-        /*
-         * Disabled to make sure that configuration changes does not cause problems with appveyor
-         */
         [Test, NonParallelizable]
         public void TestUseV1ResultParser()
         {
diff --git a/Snowflake.Data.Tests/Mock/MockRetryUntilRestTimeout.cs b/Snowflake.Data.Tests/Mock/MockRetryUntilRestTimeout.cs
index 8d27a00aa..c9f9a665a 100644
--- a/Snowflake.Data.Tests/Mock/MockRetryUntilRestTimeout.cs
+++ b/Snowflake.Data.Tests/Mock/MockRetryUntilRestTimeout.cs
@@ -31,7 +31,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
                                                               string sid = "")
         {
             // Override the http timeout and set to 1ms to force all http request to timeout and retry
-            message.Properties[BaseRestRequest.HTTP_REQUEST_TIMEOUT_KEY] = TimeSpan.FromMilliseconds(1);
+            message.Properties[BaseRestRequest.HTTP_REQUEST_TIMEOUT_KEY] = TimeSpan.FromTicks(0);
             return await (base.SendAsync(message, restTimeout, externalCancellationToken).ConfigureAwait(false));
         }
     }
diff --git a/Snowflake.Data.Tests/Mock/MockSnowflakeDbConnection.cs b/Snowflake.Data.Tests/Mock/MockSnowflakeDbConnection.cs
index aa342fe68..0f1758636 100644
--- a/Snowflake.Data.Tests/Mock/MockSnowflakeDbConnection.cs
+++ b/Snowflake.Data.Tests/Mock/MockSnowflakeDbConnection.cs
@@ -92,5 +92,10 @@ private void OnSessionEstablished()
         {
             _connectionState = ConnectionState.Open;
         }
+        
+        protected override bool CanReuseSession(TransactionRollbackStatus transactionRollbackStatus)
+        {
+            return false;
+        }
     }
 }
diff --git a/Snowflake.Data/Client/SnowflakeDbConnection.cs b/Snowflake.Data/Client/SnowflakeDbConnection.cs
index 615bcc879..bd044ce09 100755
--- a/Snowflake.Data/Client/SnowflakeDbConnection.cs
+++ b/Snowflake.Data/Client/SnowflakeDbConnection.cs
@@ -37,7 +37,7 @@ public class SnowflakeDbConnection : DbConnection
         // Will fix that in a separated PR though as it's a different issue
         private static Boolean _isArrayBindStageCreated;
 
-        private enum TransactionRollbackStatus
+        protected enum TransactionRollbackStatus
         {
             Undefined, // used to indicate ignored transaction status when pool disabled
             Success,
@@ -232,7 +232,7 @@ public Task CloseAsync(CancellationToken cancellationToken)
             return taskCompletionSource.Task;
         }
 
-        private bool CanReuseSession(TransactionRollbackStatus transactionRollbackStatus)
+        protected virtual bool CanReuseSession(TransactionRollbackStatus transactionRollbackStatus)
         {
             return SnowflakeDbConnectionPool.GetPooling() && 
                    transactionRollbackStatus == TransactionRollbackStatus.Success;
@@ -246,39 +246,28 @@ public override void Open()
                 logger.Debug($"Open with a connection already opened: {_connectionState}");
                 return;
             }
-            SfSession = SnowflakeDbConnectionPool.GetSession(this.ConnectionString);
-            if (SfSession != null)
+            try
             {
+                OnSessionConnecting();
+                SfSession = SnowflakeDbConnectionPool.GetSession(ConnectionString, Password);
+                if (SfSession == null)
+                    throw new SnowflakeDbException(SFError.INTERNAL_ERROR, "Could not open session");
                 logger.Debug($"Connection open with pooled session: {SfSession.sessionId}");
+                OnSessionEstablished();
             }
-            else
+            catch (Exception e)
             {
-                SetSession();
-                try
-                {
-                    SfSession.Open();
-                }
-                catch (Exception e)
-                {
-                    // Otherwise when Dispose() is called, the close request would timeout.
-                    _connectionState = ConnectionState.Closed;
-                    logger.Error("Unable to connect", e);
-                    if (!(e.GetType() == typeof(SnowflakeDbException)))
-                    {
-                        throw
-                           new SnowflakeDbException(
-                               e,
-                               SnowflakeDbException.CONNECTION_FAILURE_SSTATE,
-                               SFError.INTERNAL_ERROR,
-                               "Unable to connect. " + e.Message);
-                    }
-                    else
-                    {
-                        throw;
-                    }
-                }
+                // Otherwise when Dispose() is called, the close request would timeout.
+                _connectionState = ConnectionState.Closed;
+                logger.Error("Unable to connect: ", e);
+                if (e is SnowflakeDbException)
+                    throw;
+                throw new SnowflakeDbException(
+                        e,
+                        SnowflakeDbException.CONNECTION_FAILURE_SSTATE,
+                        SFError.INTERNAL_ERROR,
+                        "Unable to connect. " + e.Message);
             }
-            OnSessionEstablished();
         }
 
         public override Task OpenAsync(CancellationToken cancellationToken)
@@ -289,19 +278,11 @@ public override Task OpenAsync(CancellationToken cancellationToken)
                 logger.Debug($"Open with a connection already opened: {_connectionState}");
                 return Task.CompletedTask;
             }
-            SfSession = SnowflakeDbConnectionPool.GetSession(this.ConnectionString);
-            if (SfSession != null)
-            {
-                logger.Debug($"Connection open with pooled session: {SfSession.sessionId}");
-                OnSessionEstablished();
-                return Task.CompletedTask;
-            }
-
             registerConnectionCancellationCallback(cancellationToken);
-            SetSession();
-
-            return SfSession.OpenAsync(cancellationToken).ContinueWith(
-                previousTask =>
+            OnSessionConnecting();
+            return SnowflakeDbConnectionPool
+                .GetSessionAsync(ConnectionString, Password, cancellationToken)
+                .ContinueWith(previousTask =>
                 {
                     if (previousTask.IsFaulted)
                     {
@@ -322,8 +303,9 @@ public override Task OpenAsync(CancellationToken cancellationToken)
                     }
                     else
                     {
-                        logger.Debug("All good");
                         // Only continue if the session was opened successfully
+                        SfSession = previousTask.Result;
+                        logger.Debug($"Connection open with pooled session: {SfSession.sessionId}");
                         OnSessionEstablished();
                     }
                 },
@@ -345,19 +327,14 @@ public void SetArrayBindStageCreated()
             _isArrayBindStageCreated = true;
         }
 
-        /// <summary>
-        /// Create a new SFsession with the connection string settings.
-        /// </summary>
-        /// <exception cref="SnowflakeDbException">If the connection string can't be processed</exception>
-        private void SetSession()
+        private void OnSessionConnecting()
         {
-            SfSession = new SFSession(ConnectionString, Password);
-            _connectionTimeout = (int)SfSession.connectionTimeout.TotalSeconds;
             _connectionState = ConnectionState.Connecting;
         }
 
         private void OnSessionEstablished()
         {
+            _connectionTimeout = (int)SfSession.connectionTimeout.TotalSeconds;
             _connectionState = ConnectionState.Open;
         }
 
diff --git a/Snowflake.Data/Client/SnowflakeDbConnectionPool.cs b/Snowflake.Data/Client/SnowflakeDbConnectionPool.cs
index 8e0093262..665047038 100644
--- a/Snowflake.Data/Client/SnowflakeDbConnectionPool.cs
+++ b/Snowflake.Data/Client/SnowflakeDbConnectionPool.cs
@@ -1,4 +1,7 @@
-using Snowflake.Data.Core;
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+using Snowflake.Data.Core;
 using Snowflake.Data.Core.Session;
 using Snowflake.Data.Log;
 
@@ -7,58 +10,72 @@ namespace Snowflake.Data.Client
     public class SnowflakeDbConnectionPool
     {
         private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<SnowflakeDbConnectionPool>();
-
-        internal static SFSession GetSession(string connStr)
+        private static readonly IConnectionManager s_connectionManager = new ConnectionManagerV1();
+        
+        internal static SFSession GetSession(string connectionString, SecureString password)
         {
             s_logger.Debug("SnowflakeDbConnectionPool::GetSession");
-            return SessionPoolSingleton.Instance.GetSession(connStr);
+            return s_connectionManager.GetSession(connectionString, password);
         }
-
+        
+        internal static Task<SFSession> GetSessionAsync(string connectionString, SecureString password, CancellationToken cancellationToken)
+        {
+            s_logger.Debug("SnowflakeDbConnectionPool::GetSessionAsync");
+            return s_connectionManager.GetSessionAsync(connectionString, password, cancellationToken);
+        }
+        
         internal static bool AddSession(SFSession session)
         {
             s_logger.Debug("SnowflakeDbConnectionPool::AddSession");
-            return SessionPoolSingleton.Instance.AddSession(session);
+            return s_connectionManager.AddSession(session);
         }
 
         public static void ClearAllPools()
         {
             s_logger.Debug("SnowflakeDbConnectionPool::ClearAllPools");
-            SessionPoolSingleton.Instance.ClearAllPools();
+            s_connectionManager.ClearAllPools();
         }
 
         public static void SetMaxPoolSize(int size)
         {
-            SessionPoolSingleton.Instance.SetMaxPoolSize(size);
+            s_logger.Debug("SnowflakeDbConnectionPool::SetMaxPoolSize");
+            s_connectionManager.SetMaxPoolSize(size);
         }
 
         public static int GetMaxPoolSize()
         {
-            return SessionPoolSingleton.Instance.GetMaxPoolSize();
+            s_logger.Debug("SnowflakeDbConnectionPool::GetMaxPoolSize");
+            return s_connectionManager.GetMaxPoolSize();
         }
 
         public static void SetTimeout(long time)
         {
-            SessionPoolSingleton.Instance.SetTimeout(time);
+            s_logger.Debug("SnowflakeDbConnectionPool::SetTimeout");
+            s_connectionManager.SetTimeout(time);
         }
         
         public static long GetTimeout()
         {
-            return SessionPoolSingleton.Instance.GetTimeout();
+            s_logger.Debug("SnowflakeDbConnectionPool::GetTimeout");
+            return s_connectionManager.GetTimeout();
         }
 
         public static int GetCurrentPoolSize()
         {
-            return SessionPoolSingleton.Instance.GetCurrentPoolSize();
+            s_logger.Debug("SnowflakeDbConnectionPool::GetCurrentPoolSize");
+            return s_connectionManager.GetCurrentPoolSize();
         }
 
         public static bool SetPooling(bool isEnable)
         {
-            return SessionPoolSingleton.Instance.SetPooling(isEnable);
+            s_logger.Debug("SnowflakeDbConnectionPool::SetPooling");
+            return s_connectionManager.SetPooling(isEnable);
         }
 
         public static bool GetPooling()
         {
-            return SessionPoolSingleton.Instance.GetPooling();
+            s_logger.Debug("SnowflakeDbConnectionPool::GetPooling");
+            return s_connectionManager.GetPooling();
         }
     }
 }
diff --git a/Snowflake.Data/Core/HttpUtil.cs b/Snowflake.Data/Core/HttpUtil.cs
index 0daab0ab6..77d3807ff 100755
--- a/Snowflake.Data/Core/HttpUtil.cs
+++ b/Snowflake.Data/Core/HttpUtil.cs
@@ -364,7 +364,10 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
                         if (!httpTimeout.Equals(Timeout.InfiniteTimeSpan))
                         {
                             childCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
-                            childCts.CancelAfter(httpTimeout);
+                            if (httpTimeout.Ticks == 0)
+                                childCts.Cancel();
+                            else
+                                childCts.CancelAfter(httpTimeout);                        
                         }
                         response = await base.SendAsync(requestMessage, childCts == null ?
                             cancellationToken : childCts.Token).ConfigureAwait(false);
diff --git a/Snowflake.Data/Core/Session/ConnectionManagerV1.cs b/Snowflake.Data/Core/Session/ConnectionManagerV1.cs
new file mode 100644
index 000000000..3348f166a
--- /dev/null
+++ b/Snowflake.Data/Core/Session/ConnectionManagerV1.cs
@@ -0,0 +1,23 @@
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Snowflake.Data.Core.Session
+{
+    public sealed class ConnectionManagerV1 : IConnectionManager // abstract would make it possible not to have public GetSession or AddSession which are not API of pool
+    {
+        private readonly SessionPool _sessionPool = new SessionPool();
+        public SFSession GetSession(string connectionString, SecureString password) => _sessionPool.GetSession(connectionString, password);
+        public Task<SFSession> GetSessionAsync(string connectionString, SecureString password, CancellationToken cancellationToken)
+            => _sessionPool.GetSessionAsync(connectionString, password, cancellationToken);
+        public bool AddSession(SFSession session) => _sessionPool.AddSession(session);
+        public void ClearAllPools() => _sessionPool.ClearAllPools();
+        public void SetMaxPoolSize(int maxPoolSize) => _sessionPool.SetMaxPoolSize(maxPoolSize);
+        public int GetMaxPoolSize() => _sessionPool.GetMaxPoolSize();
+        public void SetTimeout(long connectionTimeout) => _sessionPool.SetTimeout(connectionTimeout);
+        public long GetTimeout() => _sessionPool.GetTimeout();
+        public int GetCurrentPoolSize() => _sessionPool.GetCurrentPoolSize();
+        public bool SetPooling(bool poolingEnabled) => _sessionPool.SetPooling(poolingEnabled);
+        public bool GetPooling() => _sessionPool.GetPooling();
+    }
+}
\ No newline at end of file
diff --git a/Snowflake.Data/Core/Session/IConnectionManager.cs b/Snowflake.Data/Core/Session/IConnectionManager.cs
new file mode 100644
index 000000000..77f145086
--- /dev/null
+++ b/Snowflake.Data/Core/Session/IConnectionManager.cs
@@ -0,0 +1,21 @@
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Snowflake.Data.Core.Session
+{
+    internal interface IConnectionManager
+    {
+        SFSession GetSession(string connectionString, SecureString password);
+        Task<SFSession> GetSessionAsync(string connectionString, SecureString password, CancellationToken cancellationToken);
+        bool AddSession(SFSession session);
+        void ClearAllPools();
+        void SetMaxPoolSize(int maxPoolSize);
+        int GetMaxPoolSize();
+        void SetTimeout(long connectionTimeout);
+        long GetTimeout();
+        int GetCurrentPoolSize();
+        bool SetPooling(bool poolingEnabled);
+        bool GetPooling();
+    }
+}
\ No newline at end of file
diff --git a/Snowflake.Data/Core/Session/SFSession.cs b/Snowflake.Data/Core/Session/SFSession.cs
index 6d91aa094..ad9aa07cd 100755
--- a/Snowflake.Data/Core/Session/SFSession.cs
+++ b/Snowflake.Data/Core/Session/SFSession.cs
@@ -229,7 +229,7 @@ internal void Open()
 
         internal async Task OpenAsync(CancellationToken cancellationToken)
         {
-            logger.Debug("Open Session");
+            logger.Debug("Open Session Async");
 
             if (authenticator == null)
             {
diff --git a/Snowflake.Data/Core/Session/SessionPool.cs b/Snowflake.Data/Core/Session/SessionPool.cs
index 092135e47..106d66d3f 100644
--- a/Snowflake.Data/Core/Session/SessionPool.cs
+++ b/Snowflake.Data/Core/Session/SessionPool.cs
@@ -1,14 +1,17 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Security;
+using System.Threading;
+using System.Threading.Tasks;
+using Snowflake.Data.Client;
 using Snowflake.Data.Log;
 
 namespace Snowflake.Data.Core.Session
 {
-    sealed class SessionPoolSingleton : IDisposable
+    sealed class SessionPool : IDisposable
     {
-        private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<SessionPoolSingleton>();
-        private static SessionPoolSingleton s_instance = null;
+        private static readonly SFLogger s_logger = SFLoggerFactory.GetLogger<SessionPool>();
         private static readonly object s_sessionPoolLock = new object();
 
         private readonly List<SFSession> _sessionPool;
@@ -18,7 +21,7 @@ sealed class SessionPoolSingleton : IDisposable
         private const long Timeout = 3600;
         private bool _pooling = true;
 
-        SessionPoolSingleton()
+        internal SessionPool()
         {
             lock (s_sessionPoolLock)
             {
@@ -27,7 +30,8 @@ sealed class SessionPoolSingleton : IDisposable
                 _timeout = Timeout;
             }
         }
-        ~SessionPoolSingleton()
+        
+        ~SessionPool()
         {
             ClearAllPools();
         }
@@ -37,24 +41,9 @@ public void Dispose()
             ClearAllPools();
         }
 
-        public static SessionPoolSingleton Instance
-        {
-            get
-            {
-                lock (s_sessionPoolLock)
-                {
-                    if(s_instance == null)
-                    {
-                        s_instance = new SessionPoolSingleton();
-                    }
-                    return s_instance;
-                }
-            }
-        }
-
         private void CleanExpiredSessions()
         {
-            s_logger.Debug("SessionPool::cleanExpiredSessions");
+            s_logger.Debug("SessionPool::CleanExpiredSessions");
             lock (s_sessionPoolLock)
             {
                 long timeNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
@@ -70,11 +59,27 @@ private void CleanExpiredSessions()
             }
         }
 
-        internal SFSession GetSession(string connStr)
+        internal SFSession GetSession(string connStr, SecureString password)
         {
             s_logger.Debug("SessionPool::GetSession");
             if (!_pooling)
-                return null;
+                return NewSession(connStr, password);
+            SFSession session = GetIdleSession(connStr);
+            return session ?? NewSession(connStr, password);
+        }
+        
+        internal Task<SFSession> GetSessionAsync(string connStr, SecureString password, CancellationToken cancellationToken)
+        {
+            s_logger.Debug("SessionPool::GetSessionAsync");
+            if (!_pooling)
+                return NewSessionAsync(connStr, password, cancellationToken);
+            SFSession session = GetIdleSession(connStr);
+            return session != null ? Task.FromResult(session) : NewSessionAsync(connStr, password, cancellationToken);
+        }
+
+        private SFSession GetIdleSession(string connStr)
+        {
+            s_logger.Debug("SessionPool::GetIdleSession");
             lock (s_sessionPoolLock)
             {
                 for (int i = 0; i < _sessionPool.Count; i++)
@@ -99,6 +104,50 @@ internal SFSession GetSession(string connStr)
             }
             return null;
         }
+
+        private SFSession NewSession(String connectionString, SecureString password)
+        {
+            s_logger.Debug("SessionPool::NewSession");
+            try
+            {
+                var session = new SFSession(connectionString, password);
+                session.Open();
+                return session;
+            }
+            catch (Exception e)
+            {
+                // Otherwise when Dispose() is called, the close request would timeout.
+                if (e is SnowflakeDbException)
+                    throw;
+                throw new SnowflakeDbException(
+                    e,
+                    SnowflakeDbException.CONNECTION_FAILURE_SSTATE,
+                    SFError.INTERNAL_ERROR,
+                    "Unable to connect. " + e.Message);
+            }
+        }
+
+        private Task<SFSession> NewSessionAsync(String connectionString, SecureString password, CancellationToken cancellationToken)
+        {
+            s_logger.Debug("SessionPool::NewSessionAsync");
+            var session = new SFSession(connectionString, password);
+            return session
+                .OpenAsync(cancellationToken)
+                .ContinueWith(previousTask =>
+                {
+                    if (previousTask.IsFaulted && previousTask.Exception != null)
+                        throw previousTask.Exception;
+
+                    if (previousTask.IsFaulted)
+                        throw new SnowflakeDbException(
+                            SnowflakeDbException.CONNECTION_FAILURE_SSTATE,
+                            SFError.INTERNAL_ERROR,
+                            "Failure while opening session async");
+
+                    return session;
+                }, TaskContinuationOptions.NotOnCanceled);
+        }
+
         internal bool AddSession(SFSession session)
         {
             s_logger.Debug("SessionPool::AddSession");
@@ -166,6 +215,7 @@ public int GetCurrentPoolSize()
 
         public bool SetPooling(bool isEnable)
         {
+            s_logger.Info($"SessionPool::SetPooling({isEnable})");
             if (_pooling == isEnable)
                 return false;
             _pooling = isEnable;