diff --git a/src/JustEat.StatsD.Tests/Extensions/TimingConstants.cs b/src/JustEat.StatsD.Tests/Extensions/TimingConstants.cs
index 38babf7e..e25c50a2 100644
--- a/src/JustEat.StatsD.Tests/Extensions/TimingConstants.cs
+++ b/src/JustEat.StatsD.Tests/Extensions/TimingConstants.cs
@@ -7,6 +7,6 @@ public static class TimingConstants
         public const int DelayMilliseconds = 500;
 
         public static readonly TimeSpan DeltaFast = TimeSpan.FromMilliseconds(DelayMilliseconds / 4);
-        public static readonly TimeSpan DeltaSlow = TimeSpan.FromMilliseconds(DelayMilliseconds * 2.5);
+        public static readonly TimeSpan DeltaSlow = TimeSpan.FromMilliseconds(DelayMilliseconds * 3);
     }
 }
diff --git a/src/JustEat.StatsD/ConnectedSocketPool.cs b/src/JustEat.StatsD/ConnectedSocketPool.cs
index 59d59a32..0807b50b 100644
--- a/src/JustEat.StatsD/ConnectedSocketPool.cs
+++ b/src/JustEat.StatsD/ConnectedSocketPool.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Net;
 using System.Net.Sockets;
-using System.Runtime.CompilerServices;
 
 namespace JustEat.StatsD
 {
@@ -13,23 +12,24 @@ internal sealed class ConnectedSocketPool : IDisposable
         public ConnectedSocketPool(IPEndPoint ipEndPoint)
         {
             IpEndPoint = ipEndPoint;
-
             _pool = new SimpleObjectPool<Socket>(
-                Environment.ProcessorCount,
-                pool =>
-                {
-                    var socket = UdpTransport.CreateSocket();
-                    try
-                    {
-                        socket.Connect(ipEndPoint);
-                        return socket;
-                    }
-                    catch
-                    {
-                        socket.Dispose();
-                        throw;
-                    }
-                });
+                () => CreateSocket(ipEndPoint),
+                Environment.ProcessorCount);
+        }
+
+        private static Socket CreateSocket(IPEndPoint ipEndPoint)
+        {
+            var socket = UdpTransport.CreateSocket();
+            try
+            {
+                socket.Connect(ipEndPoint);
+                return socket;
+            }
+            catch
+            {
+                socket.Dispose();
+                throw;
+            }
         }
 
         public IPEndPoint IpEndPoint { get; }
diff --git a/src/JustEat.StatsD/SimpleObjectPool.cs b/src/JustEat.StatsD/SimpleObjectPool.cs
index 7b4dfbd7..30129ff3 100644
--- a/src/JustEat.StatsD/SimpleObjectPool.cs
+++ b/src/JustEat.StatsD/SimpleObjectPool.cs
@@ -6,18 +6,18 @@ namespace JustEat.StatsD
     /// <summary>
     /// A class that provides simple thread-safe object pooling semantics.
     /// </summary>
-    public sealed class SimpleObjectPool<T> where T : class
+    internal sealed class SimpleObjectPool<T> where T : class
     {
-        private readonly Func<SimpleObjectPool<T>, T> _constructor;
+        private readonly Func<T> _itemConstructor;
         private readonly ConcurrentBag<T> _pool;
 
-        /// <summary>	Constructor that populates a pool with the given number of items. </summary>
-        /// <exception cref="ArgumentNullException"> Thrown when the constructor is null. </exception>
+        /// <summary>Constructor that populates a pool with the given number of items. </summary>
+        /// <exception cref="ArgumentNullException"> Thrown when the itemConstructor is null. </exception>
+        /// <param name="itemConstructor"> The factory method used to create new instances of the object to populate the pool. </param>
         /// <param name="initialSize"> Number of items in the pool at start </param>
-        /// <param name="constructor"> The factory method used to create new instances of the object to populate the pool. </param>
-        public SimpleObjectPool(int initialSize, Func<SimpleObjectPool<T>, T> constructor)
+        public SimpleObjectPool(Func<T> itemConstructor, int initialSize = 0)
         {
-            _constructor = constructor ?? throw new ArgumentNullException(nameof(constructor));
+            _itemConstructor = itemConstructor ?? throw new ArgumentNullException(nameof(itemConstructor));
             _pool = new ConcurrentBag<T>();
             PrePopulate(initialSize);
         }
@@ -26,10 +26,10 @@ private void PrePopulate(int size)
         {
             while (Count < size)
             {
-                var instance = _constructor(this);
+                var instance = _itemConstructor();
                 if (instance == null)
                 {
-                    throw new InvalidOperationException("constructor produced null object");
+                    throw new InvalidOperationException("itemConstructor produced null object");
                 }
 
                 _pool.Add(instance);
@@ -56,7 +56,7 @@ public T Pop()
         /// <returns>An object from the pool. </returns>
         internal T PopOrCreate()
         {
-            return Pop() ?? _constructor(this);
+            return Pop() ?? _itemConstructor();
         }
 
         /// <summary>	Pushes an object back into the pool. </summary>