diff --git a/src/Grpc.AspNetCore.Server/Internal/HttpContextStreamReader.cs b/src/Grpc.AspNetCore.Server/Internal/HttpContextStreamReader.cs
index ce256cf9f..8153adce1 100644
--- a/src/Grpc.AspNetCore.Server/Internal/HttpContextStreamReader.cs
+++ b/src/Grpc.AspNetCore.Server/Internal/HttpContextStreamReader.cs
@@ -20,14 +20,12 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Grpc.Core;
+using Grpc.Shared;
 
 namespace Grpc.AspNetCore.Server.Internal
 {
     internal class HttpContextStreamReader<TRequest> : IAsyncStreamReader<TRequest> where TRequest : class
     {
-        private static readonly Task<bool> True = Task.FromResult(true);
-        private static readonly Task<bool> False = Task.FromResult(false);
-
         private readonly HttpContextServerCallContext _serverCallContext;
         private readonly Func<DeserializationContext, TRequest> _deserializer;
         private bool _completed;
@@ -69,7 +67,9 @@ async Task<bool> MoveNextAsync(ValueTask<TRequest?> readStreamTask)
                 return MoveNextAsync(request);
             }
 
-            return ProcessPayload(request.Result) ? True : False;
+            return ProcessPayload(request.Result)
+                ? CommonGrpcProtocolHelpers.TrueTask
+                : CommonGrpcProtocolHelpers.FalseTask;
         }
 
         private bool ProcessPayload(TRequest? request)
diff --git a/src/Grpc.AspNetCore.Server/Internal/ServerCallHandlerFactory.cs b/src/Grpc.AspNetCore.Server/Internal/ServerCallHandlerFactory.cs
index 5801078ef..5f46895dd 100644
--- a/src/Grpc.AspNetCore.Server/Internal/ServerCallHandlerFactory.cs
+++ b/src/Grpc.AspNetCore.Server/Internal/ServerCallHandlerFactory.cs
@@ -25,6 +25,7 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using Log = Grpc.AspNetCore.Server.Internal.ServerCallHandlerFactoryLog;
 
 namespace Grpc.AspNetCore.Server.Internal
 {
@@ -148,24 +149,24 @@ public RequestDelegate CreateUnimplementedService()
                 return Task.CompletedTask;
             };
         }
+    }
 
-        private static class Log
-        {
-            private static readonly Action<ILogger, string, Exception?> _serviceUnimplemented =
-                LoggerMessage.Define<string>(LogLevel.Information, new EventId(1, "ServiceUnimplemented"), "Service '{ServiceName}' is unimplemented.");
+    internal static class ServerCallHandlerFactoryLog
+    {
+        private static readonly Action<ILogger, string, Exception?> _serviceUnimplemented =
+            LoggerMessage.Define<string>(LogLevel.Information, new EventId(1, "ServiceUnimplemented"), "Service '{ServiceName}' is unimplemented.");
 
-            private static readonly Action<ILogger, string, Exception?> _methodUnimplemented =
-                LoggerMessage.Define<string>(LogLevel.Information, new EventId(2, "MethodUnimplemented"), "Method '{MethodName}' is unimplemented.");
+        private static readonly Action<ILogger, string, Exception?> _methodUnimplemented =
+            LoggerMessage.Define<string>(LogLevel.Information, new EventId(2, "MethodUnimplemented"), "Method '{MethodName}' is unimplemented.");
 
-            public static void ServiceUnimplemented(ILogger logger, string serviceName)
-            {
-                _serviceUnimplemented(logger, serviceName, null);
-            }
+        public static void ServiceUnimplemented(ILogger logger, string serviceName)
+        {
+            _serviceUnimplemented(logger, serviceName, null);
+        }
 
-            public static void MethodUnimplemented(ILogger logger, string methodName)
-            {
-                _methodUnimplemented(logger, methodName, null);
-            }
+        public static void MethodUnimplemented(ILogger logger, string methodName)
+        {
+            _methodUnimplemented(logger, methodName, null);
         }
     }
 }
diff --git a/src/Grpc.AspNetCore.Server/Model/Internal/BinderServiceModelProvider.cs b/src/Grpc.AspNetCore.Server/Model/Internal/BinderServiceModelProvider.cs
index de3b49945..169e67d85 100644
--- a/src/Grpc.AspNetCore.Server/Model/Internal/BinderServiceModelProvider.cs
+++ b/src/Grpc.AspNetCore.Server/Model/Internal/BinderServiceModelProvider.cs
@@ -20,6 +20,7 @@
 using System.Diagnostics.CodeAnalysis;
 using Grpc.Shared.Server;
 using Microsoft.Extensions.Logging;
+using Log = Grpc.AspNetCore.Server.Model.Internal.BinderServiceMethodProviderLog;
 
 namespace Grpc.AspNetCore.Server.Model.Internal
 {
@@ -62,16 +63,16 @@ public void OnServiceMethodDiscovery(ServiceMethodProviderContext<TService> cont
                 Log.BindMethodNotFound(_logger, typeof(TService));
             }
         }
+    }
 
-        private static class Log
-        {
-            private static readonly Action<ILogger, Type, Exception?> _bindMethodNotFound =
-                LoggerMessage.Define<Type>(LogLevel.Debug, new EventId(1, "BindMethodNotFound"), "Could not find bind method for {ServiceType}.");
+    internal static class BinderServiceMethodProviderLog
+    {
+        private static readonly Action<ILogger, Type, Exception?> _bindMethodNotFound =
+            LoggerMessage.Define<Type>(LogLevel.Debug, new EventId(1, "BindMethodNotFound"), "Could not find bind method for {ServiceType}.");
 
-            public static void BindMethodNotFound(ILogger logger, Type serviceType)
-            {
-                _bindMethodNotFound(logger, serviceType, null);
-            }
+        public static void BindMethodNotFound(ILogger logger, Type serviceType)
+        {
+            _bindMethodNotFound(logger, serviceType, null);
         }
     }
 }
diff --git a/src/Grpc.AspNetCore.Server/Model/Internal/ServiceRouteBuilder.cs b/src/Grpc.AspNetCore.Server/Model/Internal/ServiceRouteBuilder.cs
index c13813ebe..2db7f63d1 100644
--- a/src/Grpc.AspNetCore.Server/Model/Internal/ServiceRouteBuilder.cs
+++ b/src/Grpc.AspNetCore.Server/Model/Internal/ServiceRouteBuilder.cs
@@ -27,6 +27,7 @@
 using Microsoft.AspNetCore.Routing;
 using Microsoft.AspNetCore.Routing.Patterns;
 using Microsoft.Extensions.Logging;
+using Log = Grpc.AspNetCore.Server.Model.Internal.ServiceRouteBuilderLog;
 
 namespace Grpc.AspNetCore.Server.Model.Internal
 {
@@ -184,32 +185,32 @@ private GrpcUnimplementedConstraint()
             {
             }
         }
+    }
 
-        private static class Log
-        {
-            private static readonly Action<ILogger, string, string, MethodType, string, Exception?> _addedServiceMethod =
-                LoggerMessage.Define<string, string, MethodType, string>(LogLevel.Trace, new EventId(1, "AddedServiceMethod"), "Added gRPC method '{MethodName}' to service '{ServiceName}'. Method type: '{MethodType}', route pattern: '{RoutePattern}'.");
+    internal static class ServiceRouteBuilderLog
+    {
+        private static readonly Action<ILogger, string, string, MethodType, string, Exception?> _addedServiceMethod =
+            LoggerMessage.Define<string, string, MethodType, string>(LogLevel.Trace, new EventId(1, "AddedServiceMethod"), "Added gRPC method '{MethodName}' to service '{ServiceName}'. Method type: '{MethodType}', route pattern: '{RoutePattern}'.");
 
-            private static readonly Action<ILogger, Type, Exception?> _discoveringServiceMethods =
-                LoggerMessage.Define<Type>(LogLevel.Trace, new EventId(2, "DiscoveringServiceMethods"), "Discovering gRPC methods for {ServiceType}.");
+        private static readonly Action<ILogger, Type, Exception?> _discoveringServiceMethods =
+            LoggerMessage.Define<Type>(LogLevel.Trace, new EventId(2, "DiscoveringServiceMethods"), "Discovering gRPC methods for {ServiceType}.");
 
-            private static readonly Action<ILogger, Type, Exception?> _noServiceMethodsDiscovered =
-                LoggerMessage.Define<Type>(LogLevel.Debug, new EventId(3, "NoServiceMethodsDiscovered"), "No gRPC methods discovered for {ServiceType}.");
+        private static readonly Action<ILogger, Type, Exception?> _noServiceMethodsDiscovered =
+            LoggerMessage.Define<Type>(LogLevel.Debug, new EventId(3, "NoServiceMethodsDiscovered"), "No gRPC methods discovered for {ServiceType}.");
 
-            public static void AddedServiceMethod(ILogger logger, string methodName, string serviceName, MethodType methodType, string routePattern)
-            {
-                _addedServiceMethod(logger, methodName, serviceName, methodType, routePattern, null);
-            }
+        public static void AddedServiceMethod(ILogger logger, string methodName, string serviceName, MethodType methodType, string routePattern)
+        {
+            _addedServiceMethod(logger, methodName, serviceName, methodType, routePattern, null);
+        }
 
-            public static void DiscoveringServiceMethods(ILogger logger, Type serviceType)
-            {
-                _discoveringServiceMethods(logger, serviceType, null);
-            }
+        public static void DiscoveringServiceMethods(ILogger logger, Type serviceType)
+        {
+            _discoveringServiceMethods(logger, serviceType, null);
+        }
 
-            public static void NoServiceMethodsDiscovered(ILogger logger, Type serviceType)
-            {
-                _noServiceMethodsDiscovered(logger, serviceType, null);
-            }
+        public static void NoServiceMethodsDiscovered(ILogger logger, Type serviceType)
+        {
+            _noServiceMethodsDiscovered(logger, serviceType, null);
         }
     }
 }
diff --git a/src/Grpc.Net.Client/Internal/ClientStreamWriterBase.cs b/src/Grpc.Net.Client/Internal/ClientStreamWriterBase.cs
index dd48d2765..143c85754 100644
--- a/src/Grpc.Net.Client/Internal/ClientStreamWriterBase.cs
+++ b/src/Grpc.Net.Client/Internal/ClientStreamWriterBase.cs
@@ -22,6 +22,7 @@
 using System.Threading.Tasks;
 using Grpc.Core;
 using Microsoft.Extensions.Logging;
+using Log = Grpc.Net.Client.Internal.ClientStreamWriterBaseLog;
 
 namespace Grpc.Net.Client.Internal
 {
@@ -69,32 +70,32 @@ protected bool IsWriteInProgressUnsynchronized
                 return writeTask != null && !writeTask.IsCompleted;
             }
         }
+    }
 
-        protected static class Log
-        {
-            private static readonly Action<ILogger, Exception?> _completingClientStream =
-                LoggerMessage.Define(LogLevel.Debug, new EventId(1, "CompletingClientStream"), "Completing client stream.");
+    internal static class ClientStreamWriterBaseLog
+    {
+        private static readonly Action<ILogger, Exception?> _completingClientStream =
+            LoggerMessage.Define(LogLevel.Debug, new EventId(1, "CompletingClientStream"), "Completing client stream.");
 
-            private static readonly Action<ILogger, Exception?> _writeMessageError =
-                LoggerMessage.Define(LogLevel.Error, new EventId(2, "WriteMessageError"), "Error writing message.");
+        private static readonly Action<ILogger, Exception?> _writeMessageError =
+            LoggerMessage.Define(LogLevel.Error, new EventId(2, "WriteMessageError"), "Error writing message.");
 
-            private static readonly Action<ILogger, Exception?> _completeClientStreamError =
-                LoggerMessage.Define(LogLevel.Error, new EventId(3, "CompleteClientStreamError"), "Error completing client stream.");
+        private static readonly Action<ILogger, Exception?> _completeClientStreamError =
+            LoggerMessage.Define(LogLevel.Error, new EventId(3, "CompleteClientStreamError"), "Error completing client stream.");
 
-            public static void CompletingClientStream(ILogger logger)
-            {
-                _completingClientStream(logger, null);
-            }
+        public static void CompletingClientStream(ILogger logger)
+        {
+            _completingClientStream(logger, null);
+        }
 
-            public static void WriteMessageError(ILogger logger, Exception ex)
-            {
-                _writeMessageError(logger, ex);
-            }
+        public static void WriteMessageError(ILogger logger, Exception ex)
+        {
+            _writeMessageError(logger, ex);
+        }
 
-            public static void CompleteClientStreamError(ILogger logger, Exception ex)
-            {
-                _completeClientStreamError(logger, ex);
-            }
+        public static void CompleteClientStreamError(ILogger logger, Exception ex)
+        {
+            _completeClientStreamError(logger, ex);
         }
     }
 }
diff --git a/src/Grpc.Net.Client/Internal/HttpContentClientStreamReader.cs b/src/Grpc.Net.Client/Internal/HttpContentClientStreamReader.cs
index 88315d8f6..27ac5bd3e 100644
--- a/src/Grpc.Net.Client/Internal/HttpContentClientStreamReader.cs
+++ b/src/Grpc.Net.Client/Internal/HttpContentClientStreamReader.cs
@@ -25,6 +25,7 @@
 using Grpc.Core;
 using Grpc.Shared;
 using Microsoft.Extensions.Logging;
+using Log = Grpc.Net.Client.Internal.HttpContentClientStreamReaderLog;
 
 namespace Grpc.Net.Client.Internal
 {
@@ -35,8 +36,6 @@ internal class HttpContentClientStreamReader<TRequest, TResponse> : IAsyncStream
         // Getting logger name from generic type is slow. Cached copy.
         private const string LoggerName = "Grpc.Net.Client.Internal.HttpContentClientStreamReader";
 
-        private static readonly Task<bool> FinishedTask = Task.FromResult(false);
-
         private readonly GrpcCall<TRequest, TResponse> _call;
         private readonly ILogger _logger;
         private readonly object _moveNextLock;
@@ -90,7 +89,7 @@ public Task<bool> MoveNext(CancellationToken cancellationToken)
                 if (status.StatusCode == StatusCode.OK)
                 {
                     // Response is finished and it was successful so just return false
-                    return FinishedTask;
+                    return CommonGrpcProtocolHelpers.FalseTask;
                 }
                 else
                 {
@@ -247,16 +246,16 @@ private bool IsMoveNextInProgressUnsynchronized
                 return moveNextTask != null && !moveNextTask.IsCompleted;
             }
         }
+    }
 
-        private static class Log
-        {
-            private static readonly Action<ILogger, Exception> _readMessageError =
-                LoggerMessage.Define(LogLevel.Error, new EventId(1, "ReadMessageError"), "Error reading message.");
+    internal static class HttpContentClientStreamReaderLog
+    {
+        private static readonly Action<ILogger, Exception> _readMessageError =
+            LoggerMessage.Define(LogLevel.Error, new EventId(1, "ReadMessageError"), "Error reading message.");
 
-            public static void ReadMessageError(ILogger logger, Exception ex)
-            {
-                _readMessageError(logger, ex);
-            }
+        public static void ReadMessageError(ILogger logger, Exception ex)
+        {
+            _readMessageError(logger, ex);
         }
     }
 }
diff --git a/src/Grpc.Net.Client/Internal/HttpContentClientStreamWriter.cs b/src/Grpc.Net.Client/Internal/HttpContentClientStreamWriter.cs
index 62587ca67..ebb57e25c 100644
--- a/src/Grpc.Net.Client/Internal/HttpContentClientStreamWriter.cs
+++ b/src/Grpc.Net.Client/Internal/HttpContentClientStreamWriter.cs
@@ -21,6 +21,7 @@
 using System.Threading.Tasks;
 using Grpc.Core;
 using Grpc.Shared;
+using Log = Grpc.Net.Client.Internal.ClientStreamWriterBaseLog;
 
 #if NETSTANDARD2_0
 using ValueTask = System.Threading.Tasks.Task;
diff --git a/src/Grpc.Net.Client/Internal/Retry/HedgingCall.cs b/src/Grpc.Net.Client/Internal/Retry/HedgingCall.cs
index 737ef3a76..8b3026c2b 100644
--- a/src/Grpc.Net.Client/Internal/Retry/HedgingCall.cs
+++ b/src/Grpc.Net.Client/Internal/Retry/HedgingCall.cs
@@ -24,6 +24,7 @@
 using System.Threading.Tasks;
 using Grpc.Core;
 using Grpc.Shared;
+using Log = Grpc.Net.Client.Internal.Retry.RetryCallBaseLog;
 
 namespace Grpc.Net.Client.Internal.Retry
 {
diff --git a/src/Grpc.Net.Client/Internal/Retry/RetryCall.cs b/src/Grpc.Net.Client/Internal/Retry/RetryCall.cs
index 4b843a08c..0acad90c0 100644
--- a/src/Grpc.Net.Client/Internal/Retry/RetryCall.cs
+++ b/src/Grpc.Net.Client/Internal/Retry/RetryCall.cs
@@ -23,6 +23,7 @@
 using System.Threading.Tasks;
 using Grpc.Core;
 using Grpc.Shared;
+using Log = Grpc.Net.Client.Internal.Retry.RetryCallBaseLog;
 
 namespace Grpc.Net.Client.Internal.Retry
 {
diff --git a/src/Grpc.Net.Client/Internal/Retry/RetryCallBase.Log.cs b/src/Grpc.Net.Client/Internal/Retry/RetryCallBase.Log.cs
deleted file mode 100644
index 1b5c6922e..000000000
--- a/src/Grpc.Net.Client/Internal/Retry/RetryCallBase.Log.cs
+++ /dev/null
@@ -1,128 +0,0 @@
-#region Copyright notice and license
-
-// Copyright 2019 The gRPC Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#endregion
-
-using System;
-using Grpc.Core;
-using Microsoft.Extensions.Logging;
-
-namespace Grpc.Net.Client.Internal.Retry
-{
-    internal partial class RetryCallBase<TRequest, TResponse> : IGrpcCall<TRequest, TResponse>
-        where TRequest : class
-        where TResponse : class
-    {
-        protected static class Log
-        {
-            private static readonly Action<ILogger, StatusCode, int, bool, Exception?> _retryEvaluated =
-                LoggerMessage.Define<StatusCode, int, bool>(LogLevel.Debug, new EventId(1, "RetryEvaluated"), "Evaluated retry for failed gRPC call. Status code: '{StatusCode}', Attempt: {AttemptCount}, Retry: {WillRetry}");
-
-            private static readonly Action<ILogger, string, Exception?> _retryPushbackReceived =
-                LoggerMessage.Define<string>(LogLevel.Debug, new EventId(2, "RetryPushbackReceived"), "Retry pushback of '{RetryPushback}' received from the failed gRPC call.");
-
-            private static readonly Action<ILogger, TimeSpan, Exception?> _startingRetryDelay =
-                LoggerMessage.Define<TimeSpan>(LogLevel.Trace, new EventId(3, "StartingRetryDelay"), "Starting retry delay of {DelayDuration}.");
-
-            private static readonly Action<ILogger, Exception> _errorRetryingCall =
-                LoggerMessage.Define(LogLevel.Error, new EventId(4, "ErrorRetryingCall"), "Error retrying gRPC call.");
-
-            private static readonly Action<ILogger, int, Exception?> _sendingBufferedMessages =
-                LoggerMessage.Define<int>(LogLevel.Trace, new EventId(5, "SendingBufferedMessages"), "Sending {MessageCount} buffered messages from previous failed gRPC calls.");
-
-            private static readonly Action<ILogger, int, long, Exception?> _messageAddedToBuffer =
-                LoggerMessage.Define<int, long>(LogLevel.Trace, new EventId(6, "MessageAddedToBuffer"), "Message with {MessageSize} bytes added to the buffer. There are {CallBufferSize} bytes buffered for this call.");
-
-            private static readonly Action<ILogger, CommitReason, Exception?> _callCommited =
-                LoggerMessage.Define<CommitReason>(LogLevel.Debug, new EventId(7, "CallCommited"), "Call commited. Reason: {CommitReason}");
-
-            private static readonly Action<ILogger, Exception?> _startingRetryWorker =
-                LoggerMessage.Define(LogLevel.Trace, new EventId(8, "StartingRetryWorker"), "Starting retry worker.");
-
-            private static readonly Action<ILogger, Exception?> _stoppingRetryWorker =
-                LoggerMessage.Define(LogLevel.Trace, new EventId(9, "StoppingRetryWorker"), "Stopping retry worker.");
-
-            private static readonly Action<ILogger, int, int, Exception?> _maxAttemptsLimited =
-                LoggerMessage.Define<int, int>(LogLevel.Debug, new EventId(10, "MaxAttemptsLimited"), "The method has {ServiceConfigMaxAttempts} attempts specified in the service config. The number of attempts has been limited by channel configuration to {ChannelMaxAttempts}.");
-
-            private static readonly Action<ILogger, Exception?> _additionalCallsBlockedByRetryThrottling =
-                LoggerMessage.Define(LogLevel.Debug, new EventId(11, "AdditionalCallsBlockedByRetryThrottling"), "Additional calls blocked by retry throttling.");
-
-            private static readonly Action<ILogger, int, Exception?> _startingAttempt =
-                LoggerMessage.Define<int>(LogLevel.Debug, new EventId(12, "StartingAttempt"), "Starting attempt {AttemptCount}.");
-
-            internal static void RetryEvaluated(ILogger logger, StatusCode statusCode, int attemptCount, bool willRetry)
-            {
-                _retryEvaluated(logger, statusCode, attemptCount, willRetry, null);
-            }
-
-            internal static void RetryPushbackReceived(ILogger logger, string retryPushback)
-            {
-                _retryPushbackReceived(logger, retryPushback, null);
-            }
-
-            internal static void StartingRetryDelay(ILogger logger, TimeSpan delayDuration)
-            {
-                _startingRetryDelay(logger, delayDuration, null);
-            }
-
-            internal static void ErrorRetryingCall(ILogger logger, Exception ex)
-            {
-                _errorRetryingCall(logger, ex);
-            }
-
-            internal static void SendingBufferedMessages(ILogger logger, int messageCount)
-            {
-                _sendingBufferedMessages(logger, messageCount, null);
-            }
-
-            internal static void MessageAddedToBuffer(ILogger logger, int messageSize, long callBufferSize)
-            {
-                _messageAddedToBuffer(logger, messageSize, callBufferSize, null);
-            }
-
-            internal static void CallCommited(ILogger logger, CommitReason commitReason)
-            {
-                _callCommited(logger, commitReason, null);
-            }
-
-            internal static void StartingRetryWorker(ILogger logger)
-            {
-                _startingRetryWorker(logger, null);
-            }
-
-            internal static void StoppingRetryWorker(ILogger logger)
-            {
-                _stoppingRetryWorker(logger, null);
-            }
-
-            internal static void MaxAttemptsLimited(ILogger logger, int serviceConfigMaxAttempts, int channelMaxAttempts)
-            {
-                _maxAttemptsLimited(logger, serviceConfigMaxAttempts, channelMaxAttempts, null);
-            }
-
-            internal static void AdditionalCallsBlockedByRetryThrottling(ILogger logger)
-            {
-                _additionalCallsBlockedByRetryThrottling(logger, null);
-            }
-
-            internal static void StartingAttempt(ILogger logger, int attempts)
-            {
-                _startingAttempt(logger, attempts, null);
-            }
-        }
-    }
-}
diff --git a/src/Grpc.Net.Client/Internal/Retry/RetryCallBase.cs b/src/Grpc.Net.Client/Internal/Retry/RetryCallBase.cs
index 80013a143..3e98177bc 100644
--- a/src/Grpc.Net.Client/Internal/Retry/RetryCallBase.cs
+++ b/src/Grpc.Net.Client/Internal/Retry/RetryCallBase.cs
@@ -28,6 +28,7 @@
 using Grpc.Net.Client.Internal.Http;
 using Grpc.Shared;
 using Microsoft.Extensions.Logging;
+using Log = Grpc.Net.Client.Internal.Retry.RetryCallBaseLog;
 
 #if NETSTANDARD2_0
 using ValueTask = System.Threading.Tasks.Task;
diff --git a/src/Grpc.Net.Client/Internal/Retry/RetryCallBaseClientStreamWriter.cs b/src/Grpc.Net.Client/Internal/Retry/RetryCallBaseClientStreamWriter.cs
index 1f412c58f..1ae943303 100644
--- a/src/Grpc.Net.Client/Internal/Retry/RetryCallBaseClientStreamWriter.cs
+++ b/src/Grpc.Net.Client/Internal/Retry/RetryCallBaseClientStreamWriter.cs
@@ -21,6 +21,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Grpc.Core;
+using Log = Grpc.Net.Client.Internal.ClientStreamWriterBaseLog;
 
 namespace Grpc.Net.Client.Internal.Retry
 {
diff --git a/src/Grpc.Net.Client/Internal/Retry/RetryCallBaseLog.cs b/src/Grpc.Net.Client/Internal/Retry/RetryCallBaseLog.cs
new file mode 100644
index 000000000..582abf091
--- /dev/null
+++ b/src/Grpc.Net.Client/Internal/Retry/RetryCallBaseLog.cs
@@ -0,0 +1,123 @@
+#region Copyright notice and license
+
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#endregion
+
+using System;
+using Grpc.Core;
+using Microsoft.Extensions.Logging;
+
+namespace Grpc.Net.Client.Internal.Retry
+{
+    internal static class RetryCallBaseLog
+    {
+        private static readonly Action<ILogger, StatusCode, int, bool, Exception?> _retryEvaluated =
+            LoggerMessage.Define<StatusCode, int, bool>(LogLevel.Debug, new EventId(1, "RetryEvaluated"), "Evaluated retry for failed gRPC call. Status code: '{StatusCode}', Attempt: {AttemptCount}, Retry: {WillRetry}");
+
+        private static readonly Action<ILogger, string, Exception?> _retryPushbackReceived =
+            LoggerMessage.Define<string>(LogLevel.Debug, new EventId(2, "RetryPushbackReceived"), "Retry pushback of '{RetryPushback}' received from the failed gRPC call.");
+
+        private static readonly Action<ILogger, TimeSpan, Exception?> _startingRetryDelay =
+            LoggerMessage.Define<TimeSpan>(LogLevel.Trace, new EventId(3, "StartingRetryDelay"), "Starting retry delay of {DelayDuration}.");
+
+        private static readonly Action<ILogger, Exception> _errorRetryingCall =
+            LoggerMessage.Define(LogLevel.Error, new EventId(4, "ErrorRetryingCall"), "Error retrying gRPC call.");
+
+        private static readonly Action<ILogger, int, Exception?> _sendingBufferedMessages =
+            LoggerMessage.Define<int>(LogLevel.Trace, new EventId(5, "SendingBufferedMessages"), "Sending {MessageCount} buffered messages from previous failed gRPC calls.");
+
+        private static readonly Action<ILogger, int, long, Exception?> _messageAddedToBuffer =
+            LoggerMessage.Define<int, long>(LogLevel.Trace, new EventId(6, "MessageAddedToBuffer"), "Message with {MessageSize} bytes added to the buffer. There are {CallBufferSize} bytes buffered for this call.");
+
+        private static readonly Action<ILogger, CommitReason, Exception?> _callCommited =
+            LoggerMessage.Define<CommitReason>(LogLevel.Debug, new EventId(7, "CallCommited"), "Call commited. Reason: {CommitReason}");
+
+        private static readonly Action<ILogger, Exception?> _startingRetryWorker =
+            LoggerMessage.Define(LogLevel.Trace, new EventId(8, "StartingRetryWorker"), "Starting retry worker.");
+
+        private static readonly Action<ILogger, Exception?> _stoppingRetryWorker =
+            LoggerMessage.Define(LogLevel.Trace, new EventId(9, "StoppingRetryWorker"), "Stopping retry worker.");
+
+        private static readonly Action<ILogger, int, int, Exception?> _maxAttemptsLimited =
+            LoggerMessage.Define<int, int>(LogLevel.Debug, new EventId(10, "MaxAttemptsLimited"), "The method has {ServiceConfigMaxAttempts} attempts specified in the service config. The number of attempts has been limited by channel configuration to {ChannelMaxAttempts}.");
+
+        private static readonly Action<ILogger, Exception?> _additionalCallsBlockedByRetryThrottling =
+            LoggerMessage.Define(LogLevel.Debug, new EventId(11, "AdditionalCallsBlockedByRetryThrottling"), "Additional calls blocked by retry throttling.");
+
+        private static readonly Action<ILogger, int, Exception?> _startingAttempt =
+            LoggerMessage.Define<int>(LogLevel.Debug, new EventId(12, "StartingAttempt"), "Starting attempt {AttemptCount}.");
+
+        internal static void RetryEvaluated(ILogger logger, StatusCode statusCode, int attemptCount, bool willRetry)
+        {
+            _retryEvaluated(logger, statusCode, attemptCount, willRetry, null);
+        }
+
+        internal static void RetryPushbackReceived(ILogger logger, string retryPushback)
+        {
+            _retryPushbackReceived(logger, retryPushback, null);
+        }
+
+        internal static void StartingRetryDelay(ILogger logger, TimeSpan delayDuration)
+        {
+            _startingRetryDelay(logger, delayDuration, null);
+        }
+
+        internal static void ErrorRetryingCall(ILogger logger, Exception ex)
+        {
+            _errorRetryingCall(logger, ex);
+        }
+
+        internal static void SendingBufferedMessages(ILogger logger, int messageCount)
+        {
+            _sendingBufferedMessages(logger, messageCount, null);
+        }
+
+        internal static void MessageAddedToBuffer(ILogger logger, int messageSize, long callBufferSize)
+        {
+            _messageAddedToBuffer(logger, messageSize, callBufferSize, null);
+        }
+
+        internal static void CallCommited(ILogger logger, CommitReason commitReason)
+        {
+            _callCommited(logger, commitReason, null);
+        }
+
+        internal static void StartingRetryWorker(ILogger logger)
+        {
+            _startingRetryWorker(logger, null);
+        }
+
+        internal static void StoppingRetryWorker(ILogger logger)
+        {
+            _stoppingRetryWorker(logger, null);
+        }
+
+        internal static void MaxAttemptsLimited(ILogger logger, int serviceConfigMaxAttempts, int channelMaxAttempts)
+        {
+            _maxAttemptsLimited(logger, serviceConfigMaxAttempts, channelMaxAttempts, null);
+        }
+
+        internal static void AdditionalCallsBlockedByRetryThrottling(ILogger logger)
+        {
+            _additionalCallsBlockedByRetryThrottling(logger, null);
+        }
+
+        internal static void StartingAttempt(ILogger logger, int attempts)
+        {
+            _startingAttempt(logger, attempts, null);
+        }
+    }
+}
diff --git a/src/Shared/CommonGrpcProtocolHelpers.cs b/src/Shared/CommonGrpcProtocolHelpers.cs
index 25eccd23b..6d85c1154 100644
--- a/src/Shared/CommonGrpcProtocolHelpers.cs
+++ b/src/Shared/CommonGrpcProtocolHelpers.cs
@@ -18,11 +18,15 @@
 
 using System;
 using System.Text;
+using System.Threading.Tasks;
 
 namespace Grpc.Shared
 {
     internal static class CommonGrpcProtocolHelpers
     {
+        public static readonly Task<bool> TrueTask = Task.FromResult(true);
+        public static readonly Task<bool> FalseTask = Task.FromResult(false);
+
         // Timer and DateTime.UtcNow have a 14ms precision. Add a small delay when scheduling deadline
         // timer that tests if exceeded or not. This avoids rescheduling the deadline callback multiple
         // times when timer is triggered before DateTime.UtcNow reports the deadline has been exceeded.