Fix Default Keep Alive

src/EventStore.Client/ChannelFactory.cs

@@ -40,23 +40,27 @@ HttpMessageHandler CreateHandler() {
 					return settings.CreateHttpMessageHandler.Invoke();
 				}
 
-				var handler = new SocketsHttpHandler();
-				if (settings.ConnectivitySettings.KeepAlive.HasValue) {
-					handler.KeepAlivePingDelay = settings.ConnectivitySettings.KeepAlive.Value;
-				}
-
-				return handler;
+				return new SocketsHttpHandler {
+					KeepAlivePingDelay = settings.ConnectivitySettings.KeepAliveInterval,
+					KeepAlivePingTimeout = settings.ConnectivitySettings.KeepAliveTimeout
+				};
 			}
 #else
 			return new Channel(address.Host, address.Port, settings.ChannelCredentials ?? ChannelCredentials.Insecure,
 				GetChannelOptions());
 
 			IEnumerable<ChannelOption> GetChannelOptions() {
-				if (settings.ConnectivitySettings.KeepAlive.HasValue) {
-					yield return new ChannelOption("grpc.keepalive_time_ms",
-						(int)settings.ConnectivitySettings.KeepAlive.Value.TotalMilliseconds);
-				}
+				yield return new ChannelOption("grpc.keepalive_time_ms",
+					GetValue((int)settings.ConnectivitySettings.KeepAliveInterval.TotalMilliseconds));
+
+				yield return new ChannelOption("grpc.keepalive_timeout_ms",
+					GetValue((int)settings.ConnectivitySettings.KeepAliveTimeout.TotalMilliseconds));
 			}
+
+			static int GetValue(int value) => value switch {
+				{ } v when v < 0 => int.MaxValue,
+				_ => value
+			};
 #endif
 		}
 	}

src/EventStore.Client/EventStoreClientConnectivitySettings.cs

@@ -67,7 +67,12 @@ public class EventStoreClientConnectivitySettings {
 		/// <summary>
 		/// The optional amount of time to wait after which a keepalive ping is sent on the transport.
 		/// </summary>
-		public TimeSpan? KeepAlive { get; set; }
+		public TimeSpan KeepAliveInterval { get; set; } = TimeSpan.FromSeconds(10);
+
+		/// <summary>
+		/// The optional amount of time to wait after which a sent keepalive ping is considered timed out.
+		/// </summary>
+		public TimeSpan KeepAliveTimeout { get; set; } = TimeSpan.FromSeconds(10);
 
 		/// <summary>
 		/// True if pointing to a single EventStoreDB node.
@@ -86,7 +91,9 @@ public class EventStoreClientConnectivitySettings {
 			MaxDiscoverAttempts = 10,
 			GossipTimeout = TimeSpan.FromSeconds(5),
 			DiscoveryInterval = TimeSpan.FromMilliseconds(100),
-			NodePreference = NodePreference.Leader
+			NodePreference = NodePreference.Leader,
+			KeepAliveInterval = TimeSpan.FromSeconds(10),
+			KeepAliveTimeout =  TimeSpan.FromSeconds(10),
 		};
 	}
 }

src/EventStore.Client/EventStoreClientSettings.ConnectionString.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
+using System.Threading;
 #if !GRPC_CORE
 using System.Net.Http;
 #endif
@@ -35,7 +36,8 @@ private static class ConnectionStringParser {
 			private const string TlsVerifyCert = nameof(TlsVerifyCert);
 			private const string OperationTimeout = nameof(OperationTimeout);
 			private const string ThrowOnAppendFailure = nameof(ThrowOnAppendFailure);
-			private const string KeepAlive = nameof(KeepAlive);
+			private const string KeepAliveInterval = nameof(KeepAliveInterval);
+			private const string KeepAliveTimeout = nameof(KeepAliveTimeout);
 
 			private const string UriSchemeDiscover = "esdb+discover";
 
@@ -54,7 +56,8 @@ private static class ConnectionStringParser {
 					{TlsVerifyCert, typeof(bool)},
 					{OperationTimeout, typeof(int)},
 					{ThrowOnAppendFailure, typeof(bool)},
-					{KeepAlive, typeof(int)}
+					{KeepAliveInterval, typeof(int)},
+					{KeepAliveTimeout, typeof(int)},
 				};
 
 			public static EventStoreClientSettings Parse(string connectionString) {
@@ -166,8 +169,20 @@ private static EventStoreClientSettings CreateSettings(string scheme, (string us
 				if (typedOptions.TryGetValue(ThrowOnAppendFailure, out object throwOnAppendFailure))
 					settings.OperationOptions.ThrowOnAppendFailure = (bool)throwOnAppendFailure;
 
-				if (typedOptions.TryGetValue(KeepAlive, out var keepAliveMs)) {
-					settings.ConnectivitySettings.KeepAlive = TimeSpan.FromMilliseconds((int)keepAliveMs);
+				if (typedOptions.TryGetValue(KeepAliveInterval, out var keepAliveIntervalMs)) {
+					settings.ConnectivitySettings.KeepAliveInterval = keepAliveIntervalMs switch {
+						int value when value == -1 => Timeout.InfiniteTimeSpan,
+						int value when value >= 0 => TimeSpan.FromMilliseconds(value),
+						_ => throw new InvalidSettingException($"Invalid KeepAliveInterval: {keepAliveIntervalMs}")
+					};
+				}
+
+				if (typedOptions.TryGetValue(KeepAliveTimeout, out var keepAliveTimeoutMs)) {
+					settings.ConnectivitySettings.KeepAliveTimeout = keepAliveTimeoutMs switch {
+						int value when value == -1 => Timeout.InfiniteTimeSpan,
+						int value when value >= 0 => TimeSpan.FromMilliseconds(value),
+						_ => throw new InvalidSettingException($"Invalid KeepAliveTimeout: {keepAliveTimeoutMs}")
+					};
 				}
 
 				connSettings.Insecure = !useTls;
@@ -184,16 +199,15 @@ private static EventStoreClientSettings CreateSettings(string scheme, (string us
 
 #if !GRPC_CORE
 				settings.CreateHttpMessageHandler = () => {
-					var handler = new SocketsHttpHandler();
+					var handler = new SocketsHttpHandler {
+						KeepAlivePingDelay = settings.ConnectivitySettings.KeepAliveInterval,
+						KeepAlivePingTimeout = settings.ConnectivitySettings.KeepAliveTimeout
+					};
 
 					if (typedOptions.TryGetValue(TlsVerifyCert, out var tlsVerifyCert) && !(bool)tlsVerifyCert) {
 						handler.SslOptions.RemoteCertificateValidationCallback = delegate { return true; };
 					}
 
-					if (settings.ConnectivitySettings.KeepAlive.HasValue) {
-						handler.KeepAlivePingDelay = settings.ConnectivitySettings.KeepAlive.Value;
-					}
-
 					return handler;
 				};
 #endif

src/EventStore.Client/MultiChannel.cs

@@ -4,16 +4,18 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Grpc.Core;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 
 #nullable enable
 namespace EventStore.Client {
 	internal class MultiChannel : IDisposable, IAsyncDisposable {
 		private readonly EventStoreClientSettings _settings;
 		private readonly IEndpointDiscoverer _endpointDiscoverer;
 		private readonly ConcurrentDictionary<EndPoint, ChannelBase> _channels;
+		private readonly ILogger<MultiChannel> _log;
 
 		private EndPoint? _current;
-
 		private int _disposed;
 
 		public MultiChannel(EventStoreClientSettings settings) {
@@ -22,6 +24,12 @@ public MultiChannel(EventStoreClientSettings settings) {
 				? (IEndpointDiscoverer)new SingleNodeEndpointDiscoverer(settings.ConnectivitySettings.Address)
 				: new GossipBasedEndpointDiscoverer(settings.ConnectivitySettings, new GrpcGossipClient(settings));
 			_channels = new ConcurrentDictionary<EndPoint, ChannelBase>();
+			_log = settings.LoggerFactory?.CreateLogger<MultiChannel>() ?? new NullLogger<MultiChannel>();
+
+			if (settings.ConnectivitySettings.KeepAliveInterval < TimeSpan.FromSeconds(10)) {
+				_log.LogWarning("Specified KeepAliveInterval of {interval} is less than recommended 10_000 ms.",
+					settings.ConnectivitySettings.KeepAliveInterval);
+			}
 		}
 
 		public void SetEndPoint(EndPoint value) => _current = value;

test/Directory.Build.props

@@ -1,6 +1,7 @@
 <Project>
 	<Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
 	<ItemGroup>
+		<PackageReference Include="AutoFixture.Xunit2" Version="4.15.0" />
 		<PackageReference Include="Ductus.FluentDocker" Version="2.7.3" />
 		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3"/>
 		<PackageReference Include="Polly" Version="7.2.1" />