Server call handler logger name shouldn't be service type name (#497) (#500)

JamesNK · jtattermusch · commit 5458bc04d694 · 2019-09-09T19:26:50.000+02:00
diff --git a/src/Grpc.AspNetCore.Server/Internal/CallHandlers/ServerCallHandlerBase.cs b/src/Grpc.AspNetCore.Server/Internal/CallHandlers/ServerCallHandlerBase.cs
@@ -32,6 +32,8 @@ internal abstract class ServerCallHandlerBase<TService, TRequest, TResponse>
         where TRequest : class
         where TResponse : class
     {
+        private const string LoggerName = "Grpc.AspNetCore.Server.ServerCallHandler";
+
         protected Method<TRequest, TResponse> Method { get; }
         protected GrpcServiceOptions ServiceOptions { get; }
         protected IGrpcServiceActivator<TService> ServiceActivator { get; }
@@ -49,7 +51,7 @@ protected ServerCallHandlerBase(
             ServiceOptions = serviceOptions;
             ServiceActivator = serviceActivator;
             ServiceProvider = serviceProvider;
-            Logger = loggerFactory.CreateLogger(typeof(TService));
+            Logger = loggerFactory.CreateLogger(LoggerName);
         }
 
         public Task HandleCallAsync(HttpContext httpContext)
diff --git a/test/FunctionalTests/Client/CancellationTests.cs b/test/FunctionalTests/Client/CancellationTests.cs
@@ -53,7 +53,7 @@ private async Task CancelInParallel(int tasks, bool waitForHeaders, int interati
         {
             SetExpectedErrorsFilter(writeContext =>
             {
-                if (writeContext.LoggerName == "SERVER FunctionalTestsWebsite.Services.StreamService")
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName)
                 {
                     // Kestrel cancellation error message
                     if (writeContext.Exception is IOException &&
diff --git a/test/FunctionalTests/Client/StreamingTests.cs b/test/FunctionalTests/Client/StreamingTests.cs
@@ -22,6 +22,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Google.Protobuf;
+using Grpc.AspNetCore.FunctionalTests.Infrastructure;
 using Grpc.Core;
 using Grpc.Net.Client;
 using Grpc.Tests.Shared;
@@ -368,7 +369,7 @@ writeContext.Exception is InvalidOperationException &&
                     return true;
                 }
 
-                if (writeContext.LoggerName == "SERVER FunctionalTestsWebsite.Services.StreamService")
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName)
                 {
                     return true;
                 }
diff --git a/test/FunctionalTests/Infrastructure/TestConstants.cs b/test/FunctionalTests/Infrastructure/TestConstants.cs
@@ -0,0 +1,25 @@
+﻿#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
+
+namespace Grpc.AspNetCore.FunctionalTests.Infrastructure
+{
+    internal static class TestConstants
+    {
+        public const string ServerCallHandlerTestName = "SERVER Grpc.AspNetCore.Server.ServerCallHandler";
+    }
+}
diff --git a/test/FunctionalTests/Server/ClientStreamingMethodTests.cs b/test/FunctionalTests/Server/ClientStreamingMethodTests.cs
@@ -81,15 +81,15 @@ public async Task CompleteThenIncompleteMessage_ErrorResponse()
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                if (writeContext.LoggerName == "SERVER " + typeof(CounterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "RpcConnectionError" &&
                     writeContext.State.ToString() == "Error status code 'Internal' raised." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Incomplete message.")
                 {
                     return true;
                 }
 
-                if (writeContext.LoggerName == "SERVER " + typeof(CounterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "ErrorReadingMessage" &&
                     writeContext.State.ToString() == "Error reading message." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Incomplete message.")
@@ -139,7 +139,7 @@ public async Task ServerMethodReturnsNull_FailureResponse()
 
             SetExpectedErrorsFilter(writeContext =>
             {
-                return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&
+                return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                        writeContext.EventId.Name == "RpcConnectionError" &&
                        writeContext.State.ToString() == "Error status code 'Cancelled' raised." &&
                        GetRpcExceptionDetail(writeContext.Exception) == "No message returned from method.";
@@ -246,7 +246,7 @@ async Task<CounterReply> AccumulateCount(IAsyncStreamReader<CounterRequest> requ
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName;
+                return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName;
             });
 
             var method = Fixture.DynamicGrpc.AddClientStreamingMethod<CounterRequest, CounterReply>(AccumulateCount);
diff --git a/test/FunctionalTests/Server/CompressionTests.cs b/test/FunctionalTests/Server/CompressionTests.cs
@@ -223,14 +223,14 @@ public async Task SendCompressedMessageWithIdentity_ReturnInternalError()
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "RpcConnectionError" &&
                     writeContext.State.ToString() == "Error status code 'Internal' raised.")
                 {
                     return true;
                 }
 
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "ErrorReadingMessage" &&
                     writeContext.State.ToString() == "Error reading message.")
                 {
@@ -291,15 +291,15 @@ public async Task SendCompressedMessageWithUnsupportedEncoding_ReturnUnimplement
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "RpcConnectionError" &&
                     writeContext.State.ToString() == "Error status code 'Unimplemented' raised." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Unsupported grpc-encoding value 'DOES_NOT_EXIST'. Supported encodings: identity, gzip")
                 {
                     return true;
                 }
 
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "ErrorReadingMessage" &&
                     writeContext.State.ToString() == "Error reading message." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Unsupported grpc-encoding value 'DOES_NOT_EXIST'. Supported encodings: identity, gzip")
@@ -360,15 +360,15 @@ public async Task SendCompressedMessageWithoutEncodingHeader_ServerErrorResponse
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "RpcConnectionError" &&
                     writeContext.State.ToString() == "Error status code 'Internal' raised." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Request did not include grpc-encoding value with compressed message.")
                 {
                     return true;
                 }
 
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "ErrorReadingMessage" &&
                     writeContext.State.ToString() == "Error reading message." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Request did not include grpc-encoding value with compressed message.")
diff --git a/test/FunctionalTests/Server/DeadlineTests.cs b/test/FunctionalTests/Server/DeadlineTests.cs
@@ -146,7 +146,7 @@ static async Task WriteUntilError(HelloRequest request, IServerStreamWriter<Hell
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&
+                return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                        writeContext.EventId.Name == "ErrorExecutingServiceMethod" &&
                        writeContext.State.ToString() == "Error when executing service method 'WriteUntilError'." &&
                        writeContext.Exception!.Message == "Cannot write message after request is complete.";
diff --git a/test/FunctionalTests/Server/MaxMessageSizeTests.cs b/test/FunctionalTests/Server/MaxMessageSizeTests.cs
@@ -36,15 +36,15 @@ public async Task ReceivedMessageExceedsSize_ThrowError()
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "RpcConnectionError" &&
                     writeContext.State.ToString() == "Error status code 'ResourceExhausted' raised." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Received message exceeds the maximum configured message size.")
                 {
                     return true;
                 }
 
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "ErrorReadingMessage" &&
                     writeContext.State.ToString() == "Error reading message." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Received message exceeds the maximum configured message size.")
@@ -78,15 +78,15 @@ public async Task SentMessageExceedsSize_ThrowError()
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "RpcConnectionError" &&
                     writeContext.State.ToString() == "Error status code 'ResourceExhausted' raised." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Sending message exceeds the maximum configured message size.")
                 {
                     return true;
                 }
 
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "ErrorSendingMessage" &&
                     writeContext.State.ToString() == "Error sending message." &&
                     GetRpcExceptionDetail(writeContext.Exception) == "Sending message exceeds the maximum configured message size.")
diff --git a/test/FunctionalTests/Server/UnaryMethodTests.cs b/test/FunctionalTests/Server/UnaryMethodTests.cs
@@ -101,14 +101,14 @@ public async Task AdditionalDataAfterStreamedMessage_ErrorResponse()
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "RpcConnectionError" &&
                     writeContext.State.ToString() == "Error status code 'Internal' raised.")
                 {
                     return true;
                 }
 
-                if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&
+                if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                     writeContext.EventId.Name == "ErrorReadingMessage" &&
                     writeContext.State.ToString() == "Error reading message.")
                 {
@@ -164,7 +164,7 @@ static async Task<HelloReply> ReturnHeadersTwice(HelloRequest request, ServerCal
             // Arrange
             SetExpectedErrorsFilter(writeContext =>
             {
-                return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&
+                return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                        writeContext.EventId.Name == "ErrorExecutingServiceMethod" &&
                        writeContext.State.ToString() == "Error when executing service method 'ReturnHeadersTwice'." &&
                        writeContext.Exception!.Message == "Response headers can only be sent once per call.";
@@ -200,7 +200,7 @@ public async Task ServerMethodReturnsNull_FailureResponse()
 
             SetExpectedErrorsFilter(writeContext =>
             {
-                return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&
+                return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                        writeContext.EventId.Name == "RpcConnectionError" &&
                        writeContext.State.ToString() == "Error status code 'Cancelled' raised." &&
                        GetRpcExceptionDetail(writeContext.Exception) == "No message returned from method.";
@@ -239,7 +239,7 @@ public async Task ServerMethodThrowsExceptionWithTrailers_FailureResponse()
 
             SetExpectedErrorsFilter(writeContext =>
             {
-                return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&
+                return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                        writeContext.EventId.Name == "RpcConnectionError" &&
                        writeContext.State.ToString() == "Error status code 'Unknown' raised." &&
                        GetRpcExceptionDetail(writeContext.Exception) == "User error";
@@ -316,7 +316,7 @@ static Task<Empty> ReturnContextInfoInTrailers(Empty request, ServerCallContext
 
             SetExpectedErrorsFilter(writeContext =>
             {
-                return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&
+                return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&
                        writeContext.EventId.Name == "ErrorExecutingServiceMethod";
             });
 

Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ private async Task CancelInParallel(int tasks, bool waitForHeaders, int interati`
`53`	`53`	`{`
`54`	`54`	`SetExpectedErrorsFilter(writeContext =>`
`55`	`55`	`{`
`56`		`- if (writeContext.LoggerName == "SERVER FunctionalTestsWebsite.Services.StreamService")`
	`56`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName)`
`57`	`57`	`{`
`58`	`58`	`// Kestrel cancellation error message`
`59`	`59`	`if (writeContext.Exception is IOException &&`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@`
`22`	`22`	`using System.Threading;`
`23`	`23`	`using System.Threading.Tasks;`
`24`	`24`	`using Google.Protobuf;`
	`25`	`+using Grpc.AspNetCore.FunctionalTests.Infrastructure;`
`25`	`26`	`using Grpc.Core;`
`26`	`27`	`using Grpc.Net.Client;`
`27`	`28`	`using Grpc.Tests.Shared;`
`@@ -368,7 +369,7 @@ writeContext.Exception is InvalidOperationException &&`
`368`	`369`	`return true;`
`369`	`370`	`}`
`370`	`371`
`371`		`- if (writeContext.LoggerName == "SERVER FunctionalTestsWebsite.Services.StreamService")`
	`372`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName)`
`372`	`373`	`{`
`373`	`374`	`return true;`
`374`	`375`	`}`
Original file line number	Diff line number	Diff line change
`@@ -223,14 +223,14 @@ public async Task SendCompressedMessageWithIdentity_ReturnInternalError()`
`223`	`223`	`// Arrange`
`224`	`224`	`SetExpectedErrorsFilter(writeContext =>`
`225`	`225`	`{`
`226`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`226`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`227`	`227`	`writeContext.EventId.Name == "RpcConnectionError" &&`
`228`	`228`	`writeContext.State.ToString() == "Error status code 'Internal' raised.")`
`229`	`229`	`{`
`230`	`230`	`return true;`
`231`	`231`	`}`
`232`	`232`
`233`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`233`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`234`	`234`	`writeContext.EventId.Name == "ErrorReadingMessage" &&`
`235`	`235`	`writeContext.State.ToString() == "Error reading message.")`
`236`	`236`	`{`
`@@ -291,15 +291,15 @@ public async Task SendCompressedMessageWithUnsupportedEncoding_ReturnUnimplement`
`291`	`291`	`// Arrange`
`292`	`292`	`SetExpectedErrorsFilter(writeContext =>`
`293`	`293`	`{`
`294`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`294`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`295`	`295`	`writeContext.EventId.Name == "RpcConnectionError" &&`
`296`	`296`	`writeContext.State.ToString() == "Error status code 'Unimplemented' raised." &&`
`297`	`297`	`GetRpcExceptionDetail(writeContext.Exception) == "Unsupported grpc-encoding value 'DOES_NOT_EXIST'. Supported encodings: identity, gzip")`
`298`	`298`	`{`
`299`	`299`	`return true;`
`300`	`300`	`}`
`301`	`301`
`302`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`302`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`303`	`303`	`writeContext.EventId.Name == "ErrorReadingMessage" &&`
`304`	`304`	`writeContext.State.ToString() == "Error reading message." &&`
`305`	`305`	`GetRpcExceptionDetail(writeContext.Exception) == "Unsupported grpc-encoding value 'DOES_NOT_EXIST'. Supported encodings: identity, gzip")`
`@@ -360,15 +360,15 @@ public async Task SendCompressedMessageWithoutEncodingHeader_ServerErrorResponse`
`360`	`360`	`// Arrange`
`361`	`361`	`SetExpectedErrorsFilter(writeContext =>`
`362`	`362`	`{`
`363`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`363`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`364`	`364`	`writeContext.EventId.Name == "RpcConnectionError" &&`
`365`	`365`	`writeContext.State.ToString() == "Error status code 'Internal' raised." &&`
`366`	`366`	`GetRpcExceptionDetail(writeContext.Exception) == "Request did not include grpc-encoding value with compressed message.")`
`367`	`367`	`{`
`368`	`368`	`return true;`
`369`	`369`	`}`
`370`	`370`
`371`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`371`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`372`	`372`	`writeContext.EventId.Name == "ErrorReadingMessage" &&`
`373`	`373`	`writeContext.State.ToString() == "Error reading message." &&`
`374`	`374`	`GetRpcExceptionDetail(writeContext.Exception) == "Request did not include grpc-encoding value with compressed message.")`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,7 @@ static async Task WriteUntilError(HelloRequest request, IServerStreamWriter<Hell`
`146`	`146`	`// Arrange`
`147`	`147`	`SetExpectedErrorsFilter(writeContext =>`
`148`	`148`	`{`
`149`		`- return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&`
	`149`	`+ return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`150`	`150`	`writeContext.EventId.Name == "ErrorExecutingServiceMethod" &&`
`151`	`151`	`writeContext.State.ToString() == "Error when executing service method 'WriteUntilError'." &&`
`152`	`152`	`writeContext.Exception!.Message == "Cannot write message after request is complete.";`
Original file line number	Diff line number	Diff line change
`@@ -36,15 +36,15 @@ public async Task ReceivedMessageExceedsSize_ThrowError()`
`36`	`36`	`// Arrange`
`37`	`37`	`SetExpectedErrorsFilter(writeContext =>`
`38`	`38`	`{`
`39`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`39`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`40`	`40`	`writeContext.EventId.Name == "RpcConnectionError" &&`
`41`	`41`	`writeContext.State.ToString() == "Error status code 'ResourceExhausted' raised." &&`
`42`	`42`	`GetRpcExceptionDetail(writeContext.Exception) == "Received message exceeds the maximum configured message size.")`
`43`	`43`	`{`
`44`	`44`	`return true;`
`45`	`45`	`}`
`46`	`46`
`47`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`47`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`48`	`48`	`writeContext.EventId.Name == "ErrorReadingMessage" &&`
`49`	`49`	`writeContext.State.ToString() == "Error reading message." &&`
`50`	`50`	`GetRpcExceptionDetail(writeContext.Exception) == "Received message exceeds the maximum configured message size.")`
`@@ -78,15 +78,15 @@ public async Task SentMessageExceedsSize_ThrowError()`
`78`	`78`	`// Arrange`
`79`	`79`	`SetExpectedErrorsFilter(writeContext =>`
`80`	`80`	`{`
`81`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`81`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`82`	`82`	`writeContext.EventId.Name == "RpcConnectionError" &&`
`83`	`83`	`writeContext.State.ToString() == "Error status code 'ResourceExhausted' raised." &&`
`84`	`84`	`GetRpcExceptionDetail(writeContext.Exception) == "Sending message exceeds the maximum configured message size.")`
`85`	`85`	`{`
`86`	`86`	`return true;`
`87`	`87`	`}`
`88`	`88`
`89`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`89`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`90`	`90`	`writeContext.EventId.Name == "ErrorSendingMessage" &&`
`91`	`91`	`writeContext.State.ToString() == "Error sending message." &&`
`92`	`92`	`GetRpcExceptionDetail(writeContext.Exception) == "Sending message exceeds the maximum configured message size.")`
Original file line number	Diff line number	Diff line change
`@@ -101,14 +101,14 @@ public async Task AdditionalDataAfterStreamedMessage_ErrorResponse()`
`101`	`101`	`// Arrange`
`102`	`102`	`SetExpectedErrorsFilter(writeContext =>`
`103`	`103`	`{`
`104`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`104`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`105`	`105`	`writeContext.EventId.Name == "RpcConnectionError" &&`
`106`	`106`	`writeContext.State.ToString() == "Error status code 'Internal' raised.")`
`107`	`107`	`{`
`108`	`108`	`return true;`
`109`	`109`	`}`
`110`	`110`
`111`		`- if (writeContext.LoggerName == "SERVER " + typeof(GreeterService).FullName &&`
	`111`	`+ if (writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`112`	`112`	`writeContext.EventId.Name == "ErrorReadingMessage" &&`
`113`	`113`	`writeContext.State.ToString() == "Error reading message.")`
`114`	`114`	`{`
`@@ -164,7 +164,7 @@ static async Task<HelloReply> ReturnHeadersTwice(HelloRequest request, ServerCal`
`164`	`164`	`// Arrange`
`165`	`165`	`SetExpectedErrorsFilter(writeContext =>`
`166`	`166`	`{`
`167`		`- return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&`
	`167`	`+ return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`168`	`168`	`writeContext.EventId.Name == "ErrorExecutingServiceMethod" &&`
`169`	`169`	`writeContext.State.ToString() == "Error when executing service method 'ReturnHeadersTwice'." &&`
`170`	`170`	`writeContext.Exception!.Message == "Response headers can only be sent once per call.";`
`@@ -200,7 +200,7 @@ public async Task ServerMethodReturnsNull_FailureResponse()`
`200`	`200`
`201`	`201`	`SetExpectedErrorsFilter(writeContext =>`
`202`	`202`	`{`
`203`		`- return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&`
	`203`	`+ return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`204`	`204`	`writeContext.EventId.Name == "RpcConnectionError" &&`
`205`	`205`	`writeContext.State.ToString() == "Error status code 'Cancelled' raised." &&`
`206`	`206`	`GetRpcExceptionDetail(writeContext.Exception) == "No message returned from method.";`
`@@ -239,7 +239,7 @@ public async Task ServerMethodThrowsExceptionWithTrailers_FailureResponse()`
`239`	`239`
`240`	`240`	`SetExpectedErrorsFilter(writeContext =>`
`241`	`241`	`{`
`242`		`- return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&`
	`242`	`+ return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`243`	`243`	`writeContext.EventId.Name == "RpcConnectionError" &&`
`244`	`244`	`writeContext.State.ToString() == "Error status code 'Unknown' raised." &&`
`245`	`245`	`GetRpcExceptionDetail(writeContext.Exception) == "User error";`
`@@ -316,7 +316,7 @@ static Task<Empty> ReturnContextInfoInTrailers(Empty request, ServerCallContext`
`316`	`316`
`317`	`317`	`SetExpectedErrorsFilter(writeContext =>`
`318`	`318`	`{`
`319`		`- return writeContext.LoggerName == "SERVER " + typeof(DynamicService).FullName &&`
	`319`	`+ return writeContext.LoggerName == TestConstants.ServerCallHandlerTestName &&`
`320`	`320`	`writeContext.EventId.Name == "ErrorExecutingServiceMethod";`
`321`	`321`	`});`
`322`	`322`