public virtual void SetUp() { _testinghost = new NonOrleansServiceTester <ConfigurableHost <IDemoService> >(); // Metric.Context("Service"); TracingContext.SetRequestID("1"); }
public async Task OneHostHasNetworkErrorShouldMoveToNextHost() { var port = DisposablePort.GetPort().Port; var dict = new Dictionary <string, string> { { "Discovery.Services.DemoService.Source", "Config" }, { "Discovery.Services.DemoService.Hosts", "host1,host2" }, { "Discovery.Services.DemoService.DefaultPort", port.ToString() } }; int counter = 0; Func <HttpClientConfiguration, HttpMessageHandler> messageHandlerFactory = _ => { var messageHandler = new MockHttpMessageHandler(); messageHandler .When("*") .Respond(req => { if (req.Method == HttpMethod.Get && req.RequestUri.Scheme == "https") { throw new HttpRequestException(); } counter++; if (req.RequestUri.Host == "host1") { throw new HttpRequestException(); } return(HttpResponseFactory.GetResponse(content: $"'{req.RequestUri.Host}'")); }); return(messageHandler); }; using (var kernel = new TestingKernel <ConsoleLog>( k => { k.Rebind <IDiscovery>().To <ServiceDiscovery.Rewrite.Discovery>().InSingletonScope(); k.Rebind <Func <HttpClientConfiguration, HttpMessageHandler> >().ToMethod(c => messageHandlerFactory); }, dict) ) { var providerFactory = kernel.Get <Func <string, ServiceProxyProvider> >(); var serviceProxy = providerFactory("DemoService"); serviceProxy.DefaultPort = port; TracingContext.SetRequestID("1"); var request = new HttpServiceRequest("testMethod", null, new Dictionary <string, object>()); for (int i = 0; i < 3; i++) { var server = await serviceProxy.Invoke(request, typeof(string)); server.ShouldBe("host2"); } counter.ShouldBe(3); } }
public virtual void SetUp() { _testinghost = new NonOrleansServiceTester <TestingHost <IDemoService> >(); _insecureClient = _testinghost.GetServiceProxy <IDemoService>(); Metric.ShutdownContext("Service"); TracingContext.SetRequestID("1"); }
public async Task ServiceProxyRpcMessageShouldRemainSame() { const string serviceName = "DemoService"; int defaultPort = DisposablePort.GetPort().Port; var dict = new Dictionary <string, string> { { $"Discovery.Services.{serviceName}.Source", "Config" }, { $"Discovery.Services.{serviceName}.Hosts", "host1" }, { $"Discovery.Services.{serviceName}.DefaultPort", defaultPort.ToString() } }; Uri uri = null; string requestMessage = null; Func <HttpClientConfiguration, HttpMessageHandler> messageHandlerFactory = _ => { var messageHandler = new MockHttpMessageHandler(); messageHandler .When("*").Respond(async req => { requestMessage = await req.Content.ReadAsStringAsync(); uri = req.RequestUri; return(HttpResponseFactory.GetResponse(HttpStatusCode.Accepted)); }); return(messageHandler); }; using (var kernel = new TestingKernel <ConsoleLog>(k => { k.Rebind <IDiscovery>().To <ServiceDiscovery.Rewrite.Discovery>().InSingletonScope(); k.Rebind <Func <HttpClientConfiguration, HttpMessageHandler> >().ToMethod(c => messageHandlerFactory); }, dict)) { var providerFactory = kernel.Get <Func <string, ServiceProxyProvider> >(); TracingContext.SetRequestID("g"); var serviceProxy = providerFactory(serviceName); string expectedHost = "override-host"; int expectedPort = DisposablePort.GetPort().Port; TracingContext.SetHostOverride(serviceName, expectedHost, expectedPort); var request = new HttpServiceRequest("testMethod", null, new Dictionary <string, object>()); using (TracingContext.Tags.SetUnencryptedTag("test", 1)) await serviceProxy.Invoke(request, typeof(string)); var body = requestMessage; Console.WriteLine($"error: {body}"); JsonConvert.DeserializeObject <GigyaRequestProtocol>(body, new JsonSerializerSettings() { MissingMemberHandling = MissingMemberHandling.Error }); uri.Host.ShouldBe(expectedHost); uri.Port.ShouldBe(expectedPort); } }
public virtual void SetUp() { unitTesting = new TestingKernel <ConsoleLog>(mockConfig: MockConfig); Metric.ShutdownContext(ServiceProxyProvider.METRICS_CONTEXT_NAME); TracingContext.SetUpStorage(); TracingContext.SetRequestID("1"); }
public void SetUp() { Metric.ShutdownContext("Service"); TracingContext.SetUpStorage(); TracingContext.SetRequestID("1"); var kernel = new TestingKernel <ConsoleLog>(); _proxyInstance = kernel.Get <IDemoService>(); }
public virtual void SetUp() { _insecureClient = _kernel.Get <IDemoService>(); _exceptionSerializer = _kernel.Get <JsonExceptionSerializer>(); Metric.ShutdownContext("Service"); TracingContext.SetUpStorage(); TracingContext.SetRequestID("1"); _testinghost = new TestingHost <IDemoService>(); _stopTask = _testinghost.RunAsync(new ServiceArguments(ServiceStartupMode.CommandLineNonInteractive)); }
public virtual void SetUp() { var kernel = new TestingKernel<ConsoleLog>(); _insecureClient = kernel.Get<IDemoService>(); _exceptionSerializer = kernel.Get<JsonExceptionSerializer>(); Metric.ShutdownContext("Service"); TracingContext.SetUpStorage(); TracingContext.SetRequestID("1"); _testinghost = new TestingHost<IDemoService>(); _stopTask = _testinghost.RunAsync(); }
public async Task AllRequestsForSameCallID_SameHostSelected() { var port = DisposablePort.GetPort().Port; var dict = new Dictionary <string, string> { { "Discovery.Services.DemoService.Source", "Config" }, { "Discovery.Services.DemoService.Hosts", "host1,host2" }, { "Discovery.Services.DemoService.DefaultPort", port.ToString() } }; Func <HttpClientConfiguration, HttpMessageHandler> messageHandlerFactory = _ => { var messageHandler = new MockHttpMessageHandler(); messageHandler .When("*") .Respond(req => HttpResponseFactory.GetResponse(content: $"'{req.RequestUri.Host}'")); return(messageHandler); }; using (var kernel = new TestingKernel <ConsoleLog>( k => { k.Rebind <IDiscovery>().To <ServiceDiscovery.Rewrite.Discovery>().InSingletonScope(); k.Rebind <Func <HttpClientConfiguration, HttpMessageHandler> >().ToMethod(c => messageHandlerFactory); }, dict)) { var providerFactory = kernel.Get <Func <string, ServiceProxyProvider> >(); var serviceProxy = providerFactory("DemoService"); serviceProxy.DefaultPort = port; //If we set Request Id we would like always to select same Host TracingContext.SetRequestID("dumyId1"); var request = new HttpServiceRequest("testMethod", null, new Dictionary <string, object>()); var hostOfFirstReq = (string)await serviceProxy.Invoke(request, typeof(string)); string host; for (int i = 0; i < 50; i++) { host = (string)await serviceProxy.Invoke(request, typeof(string)); host.ShouldBe(hostOfFirstReq); } TracingContext.SetRequestID("dumyId2"); host = (string)await serviceProxy.Invoke(request, typeof(string)); host.ShouldNotBe(hostOfFirstReq); } }
private async Task <HttpServiceRequest> ParseRequest(HttpListenerContext context) { var request = await _deserializationTime.Time(async() => { using (var streamReader = new StreamReader(context.Request.InputStream)) { var json = await streamReader.ReadToEndAsync(); return(JsonConvert.DeserializeObject <HttpServiceRequest>(json, JsonSettings)); } }); request.TracingData = request.TracingData ?? new TracingData(); request.TracingData.RequestID = request.TracingData.RequestID ?? Guid.NewGuid().ToString("N"); TracingContext.SetRequestID(request.TracingData.RequestID); TracingContext.SetSpan(request.TracingData.SpanID, request.TracingData.ParentSpanID); return(request); }
public async Task SingleGrainCall_CallSucceeds_PublishesEvent() { _flumeQueue.Clear(); var requestId = nameof(SingleGrainCall_CallSucceeds_PublishesEvent) + Guid.NewGuid(); TracingContext.SetRequestID(requestId); TracingContext.TryGetRequestID(); await _serviceProxy.Add(5, 3); var events = _flumeQueue.Events; var grainReq = events.Where(r => r.EventType == "grainReq") .Select(r => (GrainCallEvent)r) .Single(r => r.TargetType == typeof(CalculatorServiceGrain).FullName); Assert.AreEqual("Add", grainReq.TargetMethod); Assert.AreEqual(requestId, grainReq.RequestId); }
public async Task AllRequestsForSameCallID_SameHostSelected() { var dict = new Dictionary <string, string> { { "Discovery.Services.DemoService.Source", "Config" }, { "Discovery.Services.DemoService.Hosts", "host1,host2" }, { "Discovery.Services.DemoService.DefaultPort", "5555" } }; var kernel = new TestingKernel <ConsoleLog>(k => k.Rebind <IDiscoverySourceLoader>().To <DiscoverySourceLoader>().InSingletonScope(), dict); var providerFactory = kernel.Get <Func <string, ServiceProxyProvider> >(); var serviceProxy = providerFactory("DemoService"); var messageHandler = new MockHttpMessageHandler(); messageHandler .When("*") .Respond(req => HttpResponseFactory.GetResponse(content: $"'{req.RequestUri.Host}'")); serviceProxy.HttpMessageHandler = messageHandler; //If we set Request Id we would like always to select same Host TracingContext.SetRequestID("dumyId1"); var request = new HttpServiceRequest("testMethod", new Dictionary <string, object>()); var hostOfFirstReq = (string)await serviceProxy.Invoke(request, typeof(string)); string host; for (int i = 0; i < 50; i++) { host = (string)await serviceProxy.Invoke(request, typeof(string)); host.ShouldBe(hostOfFirstReq); } TracingContext.SetRequestID("dumyId2"); host = (string)await serviceProxy.Invoke(request, typeof(string)); host.ShouldNotBe(hostOfFirstReq); }
private async Task <HttpServiceRequest> ParseRequest(HttpListenerContext context) { HttpServiceRequest request; using (var streamReader = new StreamReader(context.Request.InputStream)) { var json = await streamReader.ReadToEndAsync(); request = JsonConvert.DeserializeObject <HttpServiceRequest>(json, JsonSettings); } request.TracingData = request.TracingData ?? new TracingData(); request.TracingData.RequestID = request.TracingData.RequestID ?? Guid.NewGuid().ToString("N"); TracingContext.SetRequestID(request.TracingData.RequestID); TracingContext.SetSpan(request.TracingData.SpanID, request.TracingData.ParentSpanID); TracingContext.SpanStartTime = request.TracingData.SpanStartTime; TracingContext.AbandonRequestBy = request.TracingData.AbandonRequestBy; return(request); }
public async Task SingleServerCall_CallSucceeds_PublishesEvent() { _flumeQueue.Clear(); var requestId = nameof(SingleServerCall_CallSucceeds_PublishesEvent) + Guid.NewGuid(); TracingContext.SetRequestID(requestId); TracingContext.TryGetRequestID(); await _serviceProxy.Add(5, 3); await Task.Delay(100); var events = _flumeQueue.Events; var serverReq = (ServiceCallEvent)events.Single(); Assert.AreEqual("serverReq", serverReq.EventType); Assert.AreEqual(nameof(ICalculatorService), serverReq.ServiceName); Assert.AreEqual("Add", serverReq.ServiceMethod); Assert.AreEqual(requestId, serverReq.RequestId); }
public async Task HttpsListening_CallHttpsAfterFirstHttpCall() { var host = "host1"; var httpsPortOffset = 5; var port = DisposablePort.GetPort().Port; var dict = new Dictionary <string, string> { { "Discovery.Services.DemoService.Source", "Config" }, { "Discovery.Services.DemoService.Hosts", host }, { "Discovery.Services.DemoService.DefaultPort", port.ToString() } }; int httpsTestCount = 0; Func <bool, string, HttpMessageHandler> messageHandlerFactory = (_, __) => { var messageHandler = new MockHttpMessageHandler(); messageHandler .When("https://*") .Respond(req => { if (req.RequestUri.AbsoluteUri == $"https://{host}:{port + httpsPortOffset}/") { httpsTestCount++; return(HttpResponseFactory.GetResponse(content: "'some HTTPS response'")); } if (req.RequestUri.AbsoluteUri == $"https://{host}:{port + httpsPortOffset}/DemoService.testMethod") { return(HttpResponseFactory.GetResponse(content: "'some HTTPS response'")); } throw new HttpRequestException("Invalid uri"); }); messageHandler .When("http://*") .Respond(req => { if (req.RequestUri.AbsoluteUri == $"http://{host}:{port}/DemoService.testMethod") { return(HttpResponseFactory.GetResponse(content: "'some HTTP response'")); } throw new HttpRequestException("Invalid uri"); }); return(messageHandler); }; using (var kernel = new TestingKernel <ConsoleLog>( k => { k.Rebind <IDiscovery>().To <ServiceDiscovery.Rewrite.Discovery>().InSingletonScope(); k.Rebind <Func <bool, string, HttpMessageHandler> >().ToMethod(c => messageHandlerFactory); }, dict) ) { var providerFactory = kernel.Get <Func <string, ServiceProxyProvider> >(); var serviceProxy = providerFactory("DemoService"); serviceProxy.DefaultPort = port; TracingContext.SetRequestID("1"); var request = new HttpServiceRequest("testMethod", null, new Dictionary <string, object>()); for (int i = 0; i < 10; i++) { bool httpsTestFinished = httpsTestCount > 0; var server = await serviceProxy.Invoke(request, typeof(string)); server.ShouldBe(httpsTestFinished ? "some HTTPS response" : "some HTTP response"); } Assert.That(() => httpsTestCount, Is.EqualTo(1).After(10).Seconds.PollEvery(1).Seconds); } }
public async Task HttpsDisabled_NoCertificate_CallSucceeds() { var host = "host1"; var httpsPortOffset = 5; var port = DisposablePort.GetPort().Port; var dict = new Dictionary <string, string> { { "Discovery.Services.DemoService.Source", "Config" }, { "Discovery.Services.DemoService.Hosts", host }, { "Discovery.Services.DemoService.DefaultPort", port.ToString() }, { "Discovery.Services.DemoService.UseHttpsOverride", "false" } }; int httpsTestCount = 0; bool httpsMethodCalled = false; Func <HttpClientConfiguration, HttpMessageHandler> messageHandlerFactory = _ => { var messageHandler = new MockHttpMessageHandler(); messageHandler .When("https://*") .Respond(req => HttpResponseFactory.GetResponseWithException(ExceptionSerializer, new SocketException())); messageHandler .When("http://*") .Respond(req => HttpResponseFactory.GetResponse(content: "'some HTTP response'")); return(messageHandler); }; using (var kernel = new TestingKernel <ConsoleLog>( k => { k.Rebind <IDiscovery>().To <ServiceDiscovery.Rewrite.Discovery>().InSingletonScope(); k.Rebind <Func <HttpClientConfiguration, HttpMessageHandler> >().ToMethod(c => messageHandlerFactory); var certificateLocator = Substitute.For <ICertificateLocator>(); certificateLocator .When(cl => cl.GetCertificate(Arg.Any <string>())) .Do(x => throw new Exception()); k.Rebind <ICertificateLocator>().ToConstant(certificateLocator); var httpsAuthenticator = Substitute.For <IHttpsAuthenticator>(); httpsAuthenticator .When(a => a.AddHttpMessageHandlerAuthentication(Arg.Any <HttpClientHandler>(), Arg.Any <HttpClientConfiguration>())) .Do(x => throw new Exception()); k.Rebind <IHttpsAuthenticator>().ToConstant(httpsAuthenticator); }, dict) ) { var providerFactory = kernel.Get <Func <string, ServiceProxyProvider> >(); var serviceProxy = providerFactory("DemoService"); serviceProxy.DefaultPort = port; TracingContext.SetRequestID("1"); var request = new HttpServiceRequest("testMethod", null, new Dictionary <string, object>()); await serviceProxy.Invoke(request, typeof(string)); } }
public async Task HttpsStoppedListening_FallbackToHttp() { var host = "host1"; var httpsPortOffset = 5; var port = DisposablePort.GetPort().Port; var dict = new Dictionary <string, string> { { "Discovery.Services.DemoService.Source", "Config" }, { "Discovery.Services.DemoService.Hosts", host }, { "Discovery.Services.DemoService.DefaultPort", port.ToString() }, { "Discovery.Services.DemoService.TryHttps", "true" } }; int httpsTestCount = 0; bool httpsMethodCalled = false; Func <HttpClientConfiguration, HttpMessageHandler> messageHandlerFactory = _ => { var messageHandler = new MockHttpMessageHandler(); messageHandler .When("https://*") .Respond(req => { if (httpsMethodCalled) { throw new HttpRequestException("", new WebException("", WebExceptionStatus.ProtocolError)); } if (req.RequestUri.AbsoluteUri == $"https://{host}:{port + httpsPortOffset}/") { httpsTestCount++; return(HttpResponseFactory.GetResponse(content: "'some HTTPS response'")); } if (req.RequestUri.AbsoluteUri == $"https://{host}:{port + httpsPortOffset}/DemoService.testMethod") { httpsMethodCalled = true; return(HttpResponseFactory.GetResponse(content: "'some HTTPS response'")); } throw new HttpRequestException("Invalid uri"); }); messageHandler .When("http://*") .Respond(req => { if (req.RequestUri.AbsoluteUri == $"http://{host}:{port}/DemoService.testMethod") { return(HttpResponseFactory.GetResponse(content: "'some HTTP response'")); } if (req.RequestUri.AbsoluteUri == $"http://{host}:{port}/") { return(HttpResponseFactory.GetResponse(content: "'{X-Gigya-ServerHostname: someValue}'")); } throw new HttpRequestException("Invalid uri"); }); return(messageHandler); }; using (var kernel = new TestingKernel <ConsoleLog>( k => { k.Rebind <IDiscovery>().To <ServiceDiscovery.Rewrite.Discovery>().InSingletonScope(); k.Rebind <Func <HttpClientConfiguration, HttpMessageHandler> >().ToMethod(c => messageHandlerFactory); var getConfig = k.Get <Func <DiscoveryConfig> >(); k.Rebind <Func <DiscoveryConfig> >().ToMethod(c => { var config = getConfig(); config.UseHttpsOverride = false; return(() => config); }); }, dict) ) { var providerFactory = kernel.Get <Func <string, ServiceProxyProvider> >(); var serviceProxy = providerFactory("DemoService"); serviceProxy.DefaultPort = port; TracingContext.SetRequestID("1"); var request = new HttpServiceRequest("testMethod", null, new Dictionary <string, object>()); var server = await serviceProxy.Invoke(request, typeof(string)); server.ShouldBe("some HTTP response"); Assert.That(() => httpsTestCount, Is.EqualTo(1).After(10).Seconds.PollEvery(1).Seconds); server = await serviceProxy.Invoke(request, typeof(string)); server.ShouldBe("some HTTPS response"); server = await serviceProxy.Invoke(request, typeof(string)); server.ShouldBe("some HTTP response"); } }
private async Task HandleRequest(HttpListenerContext context) { RequestTimings.ClearCurrentTimings(); using (context.Response) { var sw = Stopwatch.StartNew(); // Special endpoints should not be logged/measured/traced like regular endpoints if (await TryHandleSpecialEndpoints(context)) { return; } // Regular endpoint handling using (_activeRequestsCounter.NewContext("Request")) { RequestTimings.GetOrCreate(); // initialize request timing context string methodName = null; // Initialize with empty object for protocol backwards-compatibility. var requestData = new HttpServiceRequest { TracingData = new TracingData() }; object[] argumentsWithDefaults = null; ServiceMethod serviceMethod = null; ServiceCallEvent callEvent = _serverRequestPublisher.GetNewCallEvent(); try { try { ValidateRequest(context); await CheckSecureConnection(context); requestData = await ParseRequest(context); //----------------------------------------------------------------------------------------- // Don't move TracingContext writes main flow, IT have to be here, to avoid side changes //----------------------------------------------------------------------------------------- TracingContext.SetRequestID(requestData.TracingData.RequestID); TracingContext.SpanStartTime = requestData.TracingData.SpanStartTime; TracingContext.AbandonRequestBy = requestData.TracingData.AbandonRequestBy; TracingContext.SetParentSpan(requestData.TracingData.SpanID ?? Guid.NewGuid().ToString("N")); SetCallEventRequestData(callEvent, requestData); TracingContext.SetOverrides(requestData.Overrides); serviceMethod = ServiceEndPointDefinition.Resolve(requestData.Target); callEvent.CalledServiceName = serviceMethod.GrainInterfaceType.Name; methodName = serviceMethod.ServiceInterfaceMethod.Name; var arguments = requestData.Target.IsWeaklyTyped ? GetParametersByName(serviceMethod, requestData.Arguments) : requestData.Arguments.Values.Cast <object>().ToArray(); argumentsWithDefaults = GetConvertedAndDefaultArguments(serviceMethod.ServiceInterfaceMethod, arguments); } catch (Exception e) { callEvent.Exception = e; if (e is RequestException) { throw; } throw new RequestException("Invalid request", e); } RejectRequestIfLateOrOverloaded(); var responseJson = await GetResponse(context, serviceMethod, requestData, argumentsWithDefaults); if (await TryWriteResponse(context, responseJson, serviceCallEvent: callEvent)) { callEvent.ErrCode = 0; _successCounter.Increment(); } else { _failureCounter.Increment(); } } catch (Exception e) { callEvent.Exception = callEvent.Exception ?? e; _failureCounter.Increment(); Exception ex = GetRelevantException(e); string json = _serializationTime.Time(() => ExceptionSerializer.Serialize(ex)); await TryWriteResponse(context, json, GetExceptionStatusCode(ex), serviceCallEvent : callEvent); } finally { sw.Stop(); callEvent.ActualTotalTime = sw.Elapsed.TotalMilliseconds; _roundtripTime.Record((long)(sw.Elapsed.TotalMilliseconds * 1000000), TimeUnit.Nanoseconds); if (methodName != null) { _endpointContext.Timer(methodName, Unit.Requests).Record((long)(sw.Elapsed.TotalMilliseconds * 1000000), TimeUnit.Nanoseconds); } _serverRequestPublisher.TryPublish(callEvent, argumentsWithDefaults, serviceMethod); } } } }
private async Task HandleRequest(HttpListenerContext context, long ticks, long timeFromLastReq) { try { var deltaDelayTicks = DateTime.UtcNow.Ticks - ticks; var sw = Stopwatch.StartNew(); RequestTimings.ClearCurrentTimings(); using (context.Response) { // Special endpoints should not be logged/measured/traced like regular endpoints // Access is allowed without HTTPS verifications since they don't expose anything sensitive (e.g. config values are encrypted) if (await TryHandleSpecialEndpoints(context)) { return; } // Regular endpoint handling using (_activeRequestsCounter.NewContext("Request")) { RequestTimings.GetOrCreate(); // initialize request timing context string methodName = null; // Initialize with empty object for protocol backwards-compatibility. var requestData = new HttpServiceRequest { TracingData = new TracingData() }; object[] argumentsWithDefaults = null; ServiceMethod serviceMethod = null; ServiceCallEvent callEvent = _serverRequestPublisher.GetNewCallEvent(); try { try { await CheckSecureConnection(context); ValidateRequest(context); requestData = await ParseRequest(context); //----------------------------------------------------------------------------------------- // Don't move TracingContext writes main flow, IT have to be here, to avoid side changes //----------------------------------------------------------------------------------------- TracingContext.SetRequestID(requestData.TracingData.RequestID); TracingContext.SpanStartTime = requestData.TracingData.SpanStartTime; TracingContext.AbandonRequestBy = requestData.TracingData.AbandonRequestBy; TracingContext.SetParentSpan( requestData.TracingData.SpanID ?? Guid.NewGuid().ToString("N")); TracingContext.SetOverrides(requestData.Overrides); if (requestData.TracingData.Tags != null) { TracingContext.Tags = new ContextTags(requestData.TracingData.Tags); } TracingContext.AdditionalProperties = requestData.TracingData.AdditionalProperties; callEvent.ServiceMethodSchema = context.Request.IsSecureConnection ? "HTTPS" : "HTTP"; SetCallEventRequestData(callEvent, requestData); serviceMethod = ServiceEndPointDefinition.Resolve(requestData.Target); callEvent.CalledServiceName = serviceMethod.GrainInterfaceType.Name; methodName = serviceMethod.ServiceInterfaceMethod.Name; var arguments = requestData.Target.IsWeaklyTyped ? GetParametersByName(serviceMethod, requestData.Arguments) : requestData.Arguments.Values.Cast <object>().ToArray(); argumentsWithDefaults = GetConvertedAndDefaultArguments(serviceMethod.ServiceInterfaceMethod, arguments); if (_extendedDelayTimeLogging) { callEvent.RecvDateTicks = ticks; callEvent.ReqStartupDeltaTicks = deltaDelayTicks; callEvent.TimeFromLastReq = timeFromLastReq; var outstandingReqs = Interlocked.Read(ref OutstandingRequests); callEvent.OutstandingRequests = outstandingReqs; if (deltaDelayTicks > 10_000_000) { callEvent.CollectionCountGen0 = GC.CollectionCount(0); callEvent.CollectionCountGen1 = GC.CollectionCount(1); callEvent.CollectionCountGen2 = GC.CollectionCount(2); } } } catch (Exception e) { callEvent.Exception = e; if (e is RequestException) { throw; } throw new RequestException("Invalid request", e); } RejectRequestIfLateOrOverloaded(); var responseJson = await GetResponse(context, serviceMethod, requestData, argumentsWithDefaults); if (await TryWriteResponse(context, responseJson, serviceCallEvent: callEvent)) { callEvent.ErrCode = 0; _successCounter.Increment(); } else { _failureCounter.Increment(); } } catch (Exception e) { callEvent.Exception = callEvent.Exception ?? e; _failureCounter.Increment(); Exception ex = GetRelevantException(e); string json = _serializationTime.Time(() => ExceptionSerializer.Serialize(ex)); await TryWriteResponse(context, json, GetExceptionStatusCode(ex), serviceCallEvent : callEvent); } finally { sw.Stop(); callEvent.ActualTotalTime = sw.Elapsed.TotalMilliseconds; _roundtripTime.Record((long)(sw.Elapsed.TotalMilliseconds * 1000000), TimeUnit.Nanoseconds); if (methodName != null) { _endpointContext.Timer(methodName, Unit.Requests) .Record((long)(sw.Elapsed.TotalMilliseconds * 1000000), TimeUnit.Nanoseconds); } _serverRequestPublisher.TryPublish(callEvent, argumentsWithDefaults, serviceMethod); } } } } finally { Interlocked.Decrement(ref OutstandingRequests); } }