/// <summary> /// The method to create the controller object from the requested routing information /// This methods loads the xml file where the Controller information /// with its full qualify path stored. The XLinq is used to load the xml file. /// The xml file is queried using xlinq based upon the controllerName. /// The information received from the cml file is stored into the Dictionary<string,string> object. /// From this dictionary object the controller object is created and using the Activator object /// the controller instance is created to whcih the Logger object is passed. /// </summary> /// <param name="requestContext"></param> /// <param name="controllerName"></param> /// <returns></returns> public IController CreateController(System.Web.Routing.RequestContext requestContext, string controllerName) { IController controllerType = null; Type typeData = null; XDocument xdoc = XDocument.Load(HostingEnvironment.MapPath(@"~/Controllers.xml")); var controllerData = (from controller in xdoc.Descendants("ControllerName") select new ControllerInfo() { ControllerKey = controller.Descendants("Class").First().Value, ControllerPath = controller.Descendants("FullPath").First().Value }).ToList(); Dictionary <string, string> controllersDictionary = new Dictionary <string, string>(); foreach (var item in controllerData) { controllersDictionary.Add(item.ControllerKey, item.ControllerPath); } string controllerTypeName = null; if (controllersDictionary.TryGetValue(controllerName, out controllerTypeName)) { typeData = Type.GetType(controllerTypeName); } IRequestLogger logger = new RequestLogger(); controllerType = (IController)Activator.CreateInstance(typeData, logger); return(controllerType); }
private void Context_BeginRequest(object sender, EventArgs e) { _log.Debug("开始执行 BeginRequest"); HttpApplication context = sender as HttpApplication; requestLog = RequestLogger.CreateRequestLog(context.Request); if (!RequestLoggerEventHandler.BeginRequestLoggerHandler(context.Request, requestLog)) { return; } try { using (var requestLoggerRepository = GetConnection()) { requestLoggerRepository.AddRequestLogger(requestLog); requestLoggerRepository.SaveChange(); } }catch (Exception ex) { _log.Error(ex); throw ex; } RequestLoggerEventHandler.AlfterBeginRequestLoggerHandler(context.Request, requestLog); _log.Debug("结束执行 BeginRequest"); }
public async Task Invoke(HttpContext httpContext, RequestLogger requestLogger) { var log = new RequestLogModel(); try { log = await requestLogger.RequestIndiactor(httpContext); using (var memStream = new MemoryStream()) { var originalResponseBody = httpContext.Response.Body; httpContext.Response.Body = memStream; httpContext.Items.Add("RequestLog", log); await _next(httpContext); memStream.Position = 0; log.Response = new StreamReader(memStream).ReadToEnd(); memStream.Position = 0; await memStream.CopyToAsync(originalResponseBody); httpContext.Response.Body = originalResponseBody; } await requestLogger.ResponseIndiactor(httpContext, log); } catch (Exception ex) { await requestLogger.ExceptionIndiactor(httpContext, log, ex); throw; } }
public async Task ChecksHttpGetVerb(WebhookConfig config, HttpMethod httpMethod, string payload, HttpStatusCode expectedResponseCode, string expectedResponseBody) { var mockHttp = new MockHttpMessageHandler(); var request = mockHttp.When(httpMethod, config.Uri) .Respond(expectedResponseCode, "application/json", expectedResponseBody); var mockBigBrother = new Mock <IBigBrother>(); var httpClients = new Dictionary <string, HttpClient> { { new Uri(config.Uri).Host, mockHttp.ToHttpClient() } }; var httpClientBuilder = new HttpClientFactory(httpClients); var requestBuilder = new RequestBuilder(); var requestLogger = new RequestLogger(mockBigBrother.Object); var genericWebhookHandler = new GenericWebhookHandler( httpClientBuilder, new Mock <IAuthenticationHandlerFactory>().Object, requestBuilder, requestLogger, mockBigBrother.Object, config); await genericWebhookHandler.CallAsync(new MessageData(payload, "TestType", "subA", "service") { CorrelationId = Guid.NewGuid().ToString() }, new Dictionary <string, object>(), _cancellationToken); Assert.Equal(1, mockHttp.GetMatchCount(request)); }
public void Initialize() { _dateTimeMock .Setup(m => m.UtcNow) .Returns(_utcNow); _logger = new RequestLogger(_dateTimeMock.Object); }
public ActionResult Get(string loc1, string loc2, string profile = "", bool instructions = false, string lang = "en") { try { var from = Utility.ParseCoordinate(loc1); var to = Utility.ParseCoordinate(loc2); var route = RouterInstance.Calculate(profile, from, to); route.PruneColours(); GeoJsonFeatureCollection instr = null; if (instructions) { instr = RouterInstance.GenerateInstructions(route, lang); } RequestLogger.LogRequest(from, to); return(Json(new RouteResponse(route, instr))); } catch (ResolveException e) { Log.Error(e, "Getting a route failed (not found)"); return(NotFound(e.Message)); } catch (Exception e) { Log.Error(e, "Getting a route failed (other error)"); return(BadRequest(e.Message)); } }
protected async Task <GatewayResponse> SendRequestAsync(string endpoint, MultipartFormDataContent content) { HttpClient httpClient = new HttpClient { Timeout = TimeSpan.FromMilliseconds(Timeout) }; HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, ServiceUrl + endpoint); HttpResponseMessage response = null; try { RequestLogger?.RequestSent(content.ToString()); request.Content = content; response = await httpClient.SendAsync(request); string rawResponse = response.Content.ReadAsStringAsync().Result; RequestLogger?.ResponseReceived(rawResponse); return(new GatewayResponse { StatusCode = response.StatusCode, RequestUrl = response.RequestMessage.RequestUri.ToString(), RawResponse = rawResponse }); } catch (Exception exc) { throw new GatewayException("Error occurred while communicating with gateway.", exc); } finally { } }
public async Task<FileContentResult> GetLoRes(int id) { using (SAEONLogs.MethodCall(GetType(), new MethodCallParameters { { nameof(id), id } })) { try { var image = await dbContext.Images.FirstOrDefaultAsync(i => i.Id == id); //Guard.IsNotNull(image, nameof(image)); if (image == null) { throw new ArgumentOutOfRangeException(nameof(id)); } var fileName = Path.Combine(environment.ContentRootPath, image.Link.RemoveStartingBackSlash().RemoveStartingForwardSlash()); using (MemoryStream outStream = new MemoryStream()) using (var jpgImage = await SixLabors.ImageSharp.Image.LoadAsync(fileName)) { await jpgImage.SaveAsJpegAsync(outStream); var imageBytes = outStream.ToArray(); var result = new FileContentResult(imageBytes, MediaTypeNames.Image.Jpeg); var contentDisposition = new ContentDispositionHeaderValue("inline"); contentDisposition.FileName = Path.GetFileName(fileName); Response.Headers[HeaderNames.ContentDisposition] = contentDisposition.ToString(); await RequestLogger.LogAsync(dbContext, Request, $"{image.Name}|{image.Link}"); return result; } } catch (Exception ex) { SAEONLogs.Exception(ex); throw; } } }
internal void CheckForRoutingUpdates(HttpContextBase context) { HttpResponseBase response = context.Response; string routingUpdatesHeaderValue = response.Headers["X-RoutingEntryUpdate"]; if (string.IsNullOrEmpty(routingUpdatesHeaderValue)) { return; } response.Headers.Remove("X-RoutingEntryUpdate"); if (this.diagnostics == null) { RequestLogger logger = RequestLogger.GetLogger(context); this.diagnostics = new RouteRefresherDiagnostics(logger); } if (this.routeRefresher == null) { this.routeRefresher = new RouteRefresher(this.diagnostics); } this.diagnostics.LogRouteRefresherLatency(delegate { this.routeRefresher.ProcessRoutingUpdates(routingUpdatesHeaderValue); }); this.routeRefresher = null; this.diagnostics = null; }
public async Task ShouldNotCallGetUserNameAsyncOnceIfUnauthenticated() { var requestLogger = new RequestLogger <CreateTodoItemCommand>(_logger.Object, _currentUserService.Object, _identityService.Object); await requestLogger.Process(new CreateTodoItemCommand { ListId = 1, Title = "title" }, new CancellationToken()); _identityService.Verify(i => i.GetUserNameAsync(null), Times.Never); }
protected GatewayResponse SendRequest(HttpMethod verb, string endpoint, string data = null, Dictionary <string, string> queryStringParams = null, string contentType = null) { HttpClient httpClient = new HttpClient { Timeout = TimeSpan.FromMilliseconds(Timeout) }; var queryString = BuildQueryString(queryStringParams); HttpRequestMessage request = new HttpRequestMessage(verb, ServiceUrl + endpoint + queryString); foreach (var item in Headers) { request.Headers.Add(item.Key, item.Value); } HttpResponseMessage response = null; try { if (verb != HttpMethod.Get && data != null) { request.Content = new StringContent(data, Encoding.UTF8, contentType ?? _contentType); RequestLogger?.RequestSent(data); } response = httpClient.SendAsync(request).Result; string rawResponse = string.Empty; if (response.Content.Headers.ContentEncoding.Contains("gzip")) { var result = response.Content.ReadAsByteArrayAsync().Result; using (GZipStream gzipStream = new GZipStream(new MemoryStream(result), CompressionMode.Decompress)) { using (var stream = new MemoryStream()) { byte[] buffer = new byte[1024]; int bytesRead; while ((bytesRead = gzipStream.Read(buffer, 0, buffer.Length)) > 0) { stream.Write(buffer, 0, bytesRead); } rawResponse = new UTF8Encoding().GetString(stream.ToArray()); } } } else { rawResponse = response.Content.ReadAsStringAsync().Result; } RequestLogger?.ResponseReceived(rawResponse); return(new GatewayResponse { StatusCode = response.StatusCode, RequestUrl = response.RequestMessage.RequestUri.ToString(), RawResponse = rawResponse }); } catch (Exception exc) { throw new GatewayException("Error occurred while communicating with gateway.", exc); } finally { } }
public void NoLogger_PassThrough() { RequestLogger middleware = new RequestLogger(env => { return(TaskHelpers.Completed()); }); middleware.Invoke(Request.Create().Environment).Wait(); }
public RouteSelectorDiagnostics(RequestLogger baseLogger) { this.baseLogger = baseLogger; this.accountForestLatencies = new List <long>(2); this.globalLocatorLatencies = new List <long>(2); this.resourceForestLatencies = new List <long>(2); this.serverLocatorLatencies = new List <long>(2); this.sharedCacheLatencies = new List <long>(2); }
private void LastChanceExceptionHandler(Exception unhandledException) { RequestLogger logger = RequestLogger.GetLogger(new HttpContextWrapper(HttpContext.Current)); if (logger != null) { logger.LastChanceExceptionHandler(unhandledException); } }
public void NoLogger_PassThrough() { RequestLogger middleware = new RequestLogger(env => { return TaskHelpers.Completed(); }); middleware.Invoke(Request.Create().Environment).Wait(); }
public async Task ShouldCallGetUserNameAsyncOnceIfAuthenticated() { _currentUserService.Setup(x => x.UserId).Returns("Administrator"); var requestLogger = new RequestLogger <CreateTodoItemCommand>(_logger.Object, _currentUserService.Object, _identityService.Object); await requestLogger.Process(new CreateTodoItemCommand { ListId = 1, Title = "title" }, new CancellationToken()); _identityService.Verify(i => i.GetUserNameAsync(It.IsAny <string>()), Times.Once); }
public void TestRequestLogger_None() { RequestLogger logger = new RequestLogger(".\\log", RequestLogLevel.None); Assert.IsTrue(!Directory.Exists(".\\log\\deadletter"), "deadletter directory is created while log level is set to none"); Assert.IsTrue(!Directory.Exists(".\\log\\successful"), "successful directory is created while log level is set to none"); // These calls should do nothing, shouldn't fail either. logger.LogSuccess("body"); logger.LogFailure("body"); }
public async Task CheckWebhookCall(SubscriberConfiguration config, MessageData messageData, string expectedUri, string expectedContent) { var mockHttpHandler = new MockHttpMessageHandler(); var mockWebHookRequestWithCallback = mockHttpHandler.When(HttpMethod.Post, expectedUri) .WithContentType("application/json", expectedContent) .Respond(HttpStatusCode.OK, "application/json", "{\"msg\":\"Hello World\"}"); var mockBigBrother = new Mock <IBigBrother>(); var httpClients = new Dictionary <string, HttpClient> { { new Uri(config.Uri).Host, mockHttpHandler.ToHttpClient() }, { new Uri(config.Callback.Uri).Host, mockHttpHandler.ToHttpClient() } }; var mockTokenHandler = new Mock <IAuthenticationHandler>(); mockTokenHandler.Setup(s => s.GetTokenAsync(It.IsAny <CancellationToken>())) .ReturnsAsync(Guid.NewGuid().ToString); var mockAuthHandlerFactory = new Mock <IAuthenticationHandlerFactory>(); mockAuthHandlerFactory.Setup(s => s.GetAsync(It.IsAny <WebhookConfig>(), It.IsAny <CancellationToken>())) .ReturnsAsync(() => mockTokenHandler.Object); var httpClientBuilder = new HttpClientFactory(httpClients); var requestBuilder = new RequestBuilder(); var requestLogger = new RequestLogger(mockBigBrother.Object); var mockHandlerFactory = new Mock <IEventHandlerFactory>(); mockHandlerFactory.Setup(s => s.CreateWebhookHandler(config.Callback.Name)).Returns( new GenericWebhookHandler( httpClientBuilder, mockAuthHandlerFactory.Object, requestBuilder, requestLogger, mockBigBrother.Object, config.Callback)); var webhookResponseHandler = new WebhookResponseHandler( mockHandlerFactory.Object, httpClientBuilder, requestBuilder, mockAuthHandlerFactory.Object, requestLogger, mockBigBrother.Object, config); await webhookResponseHandler.CallAsync(messageData, new Dictionary <string, object>(), _cancellationToken); mockAuthHandlerFactory.Verify(e => e.GetAsync(It.IsAny <WebhookConfig>(), _cancellationToken), Times.Once); Assert.Equal(1, mockHttpHandler.GetMatchCount(mockWebHookRequestWithCallback)); }
public async Task ExecuteHappyPathRawContract() { var(messageData, metaData) = EventHandlerTestHelper.CreateMessageDataPayload(); var config = new WebhookConfig { Uri = "http://localhost/webhook", HttpMethod = HttpMethod.Put, EventType = "Event1", AuthenticationConfig = new AuthenticationConfig(), WebhookRequestRules = new List <WebhookRequestRule> { new WebhookRequestRule { Source = new ParserLocation { Path = "OrderCode" }, Destination = new ParserLocation { Location = Location.Uri } } } }; var mockHttp = new MockHttpMessageHandler(); var webhookRequest = mockHttp.When(HttpMethod.Put, $"{config.Uri}/{metaData["OrderCode"]}") .WithContentType("application/json", messageData.Payload) .Respond(HttpStatusCode.OK, "application/json", string.Empty); var mockBigBrother = new Mock <IBigBrother>(); var httpClients = new Dictionary <string, HttpClient> { { new Uri(config.Uri).Host, mockHttp.ToHttpClient() } }; var httpClientBuilder = new HttpClientFactory(httpClients); var requestBuilder = new RequestBuilder(); var requestLogger = new RequestLogger(mockBigBrother.Object); var genericWebhookHandler = new GenericWebhookHandler( httpClientBuilder, new Mock <IAuthenticationHandlerFactory>().Object, requestBuilder, requestLogger, mockBigBrother.Object, config); await genericWebhookHandler.CallAsync(messageData, new Dictionary <string, object>(), _cancellationToken); Assert.Equal(1, mockHttp.GetMatchCount(webhookRequest)); }
public void Logger_Logged() { RequestLogger middleware = new RequestLogger(env => { return TaskHelpers.Completed(); }); StringWriter writer = new StringWriter(); Request request = Request.Create(); request.TraceOutput = writer; middleware.Invoke(request.Environment).Wait(); Assert.That(writer.GetStringBuilder().ToString(), Is.Not.EqualTo(string.Empty)); }
public void リクエストからログ文字列に変換ができる() { var expected = @"POST http://hoge/piyo HTTP /1.1 Host: hoge Connection: Keep-Alive <request></request>"; var headers = new NameValueCollection(); headers.Add("Host", "hoge"); headers.Add("Connection", "Keep-Alive"); Assert.That(RequestLogger.ToString("POST", new Uri("http://hoge/piyo"), headers, @"<request></request>"), Is.EqualTo(expected)); }
public void UpdateRequestLogger(RequestLogger requestLogger) { var model = requestLoggers.FirstOrDefault(p => p.Id.Equals(requestLogger.Id)); if (model != null) { model.EndRequest(); } else { requestLogger.EndRequest(); AddRequestLogger(requestLogger); } }
protected GatewayResponse SendRequest(HttpMethod verb, string endpoint, string data = null, Dictionary <string, string> queryStringParams = null, string contentType = null) { HttpClient httpClient = new HttpClient(HttpClientHandlerBuilder.Build(WebProxy)) { Timeout = TimeSpan.FromMilliseconds(Timeout) }; var queryString = BuildQueryString(queryStringParams); HttpRequestMessage request = new HttpRequestMessage(verb, ServiceUrl + endpoint + queryString); foreach (var item in Headers) { request.Headers.Add(item.Key, item.Value); } if (DynamicHeaders != null) { foreach (var item in DynamicHeaders) { request.Headers.Add(item.Key, item.Value); } } HttpResponseMessage response = null; try { if (verb != HttpMethod.Get && data != null) { request.Content = new StringContent(data, Encoding.UTF8, contentType ?? _contentType); } RequestLogger?.RequestSent(GenerateRequestLog(request)); response = httpClient.SendAsync(request).Result; string rawResponse = response.Content.ReadAsStringAsync().Result; RequestLogger?.ResponseReceived(rawResponse); return(new GatewayResponse { StatusCode = response.StatusCode, RequestUrl = response.RequestMessage.RequestUri.ToString(), RawResponse = rawResponse }); } catch (Exception exc) { throw new GatewayException("Error occurred while communicating with gateway.", exc); } finally { } }
public void Logger_Logged() { RequestLogger middleware = new RequestLogger(env => { return(TaskHelpers.Completed()); }); StringWriter writer = new StringWriter(); Request request = Request.Create(); request.TraceOutput = writer; middleware.Invoke(request.Environment).Wait(); Assert.That(writer.GetStringBuilder().ToString(), Is.Not.EqualTo(string.Empty)); }
/// <summary> /// Initializes a new instance of the <see cref="SimpleBingCommercePusher"/> class. /// </summary> /// <param name="config">The pusher configurations object</param> /// <param name="checkpoint">The checkpoint to poll the data since if it's valid.</param> /// <param name="serializer">(Optional): Explicit serialier to be used.</param> public SimpleBingCommercePusher(BingCommerceConfig config, IDataCheckpoint checkpoint, IPushSerializer <IDictionary <string, object> > serializer = null) { var sdkClient = new BingCommerceIngestion(new TokenCredentials(config.AccessToken)); var logger = new RequestLogger(config.RequestLogLocation, config.RequestLog); this.config = config; this.client = new IngestionClient(sdkClient, config.TenantId, config.IndexId, config.RetryCount, logger); this.tracker = new StatusTracker(this.client, config.TrackingInterval, logger); this.taskManager = new TaskManager(config.MaxConcurrentRequests); this.checkpointAcceptor = new CheckpointAcceptor(checkpoint); this.Serializer = serializer ?? new FormatSerializer(config.PushFormat); log.Debug("Successfully created the Simple Bing Commerce Pusher with the provided access token."); }
/// <inheritdoc/> public IRequestLogger GetRequestLogger() { const string requestLoggerKey = "requestLogger"; var requestLogger = _httpContextService.GetItem <IRequestLogger>(requestLoggerKey); if (requestLogger != null) { return(requestLogger); } requestLogger = new RequestLogger(_dateTime); _httpContextService.SetItem(requestLoggerKey, requestLogger); return(requestLogger); }
protected override void OnEndRequest(HttpContext context, EventArgs e) { var requestLogger = context.Items[RequestLogger.ItemKey] as IRequestLogger; if (requestLogger == null) { return; } requestLogger.MvcLogRecord.DateResponded = DateTime.UtcNow; requestLogger.MvcLogRecord.HttpStatus = context.Response.StatusCode; requestLogger.MvcLogRecord.Error = GetExceptionMessage(context); requestLogger.WriteLog(); RequestLogger.RemoveRequestLogger(requestLogger); }
/// <summary> /// Configure the services for the web api. Adds a CORS policy and initializes /// the router and languages. /// </summary> /// <param name="services">The services of the application.</param> public void ConfigureServices(IServiceCollection services) { // Add framework services. services.AddMvc(); services.AddCors(options => { options.AddPolicy("AllowAnyOrigin", builder => builder.AllowAnyOrigin().AllowAnyHeader().WithMethods("GET")); }); services.AddDirectoryBrowser(); services.AddSingleton <IConfiguration> (Configuration); RouterInstance.Initialize(Configuration); Languages.initialize(Configuration); RequestLogger.initialize(Configuration); }
public void RequestLogger_Should_Not_Call_GetUserNameAsync_Once_If_Unauthenticated() { var logger = new Mock <ILogger <CreateTodoItemCommand> >(); var currentUserService = new Mock <ICurrentUserService>(); var identityService = new Mock <IIdentityService>(); currentUserService.Setup(x => x.UserId).Returns((string)null); IRequestPreProcessor <CreateTodoItemCommand> requestLogger = new RequestLogger <CreateTodoItemCommand>(logger.Object, currentUserService.Object, identityService.Object); requestLogger.Process(new CreateTodoItemCommand { ListId = 1, Title = "title" }, new CancellationToken()); identityService.Verify(i => i.GetUserNameAsync(null), Times.Never); }
public void RequestLogger_Should_Call_GetUserNameAsync_Once_If_Authenticated() { var logger = new Mock <ILogger <CreateProductCommand> >(); var currentUserService = new Mock <ICurrentUserService>(); var identityService = new Mock <IIdentityService>(); currentUserService.Setup(x => x.UserId).Returns(UserId); IRequestPreProcessor <CreateProductCommand> requestLogger = new RequestLogger <CreateProductCommand>(logger.Object, currentUserService.Object, identityService.Object); requestLogger.Process(new CreateProductCommand { CategoryId = 1, Title = "title" }, new CancellationToken()); identityService.Verify(i => i.GetUserNameAsync(UserId), Times.Once); }
public void RequestLogger_Should_Call_GetUserNameAsync_Once_If_Authenticated() { var logger = new Mock <ILogger <CreateSaleItemCommand> >(); var currentUserService = new Mock <ICurrentUserService>(); var identityService = new Mock <IIdentityService>(); currentUserService.Setup(x => x.UserId).Returns(UserId); IRequestPreProcessor <CreateSaleItemCommand> requestLogger = new RequestLogger <CreateSaleItemCommand>(logger.Object, currentUserService.Object, identityService.Object); requestLogger.Process(new CreateSaleItemCommand { ArticleNumber = ArticleNumber, SalesPriceInEuro = SalesPriceInEuro, DateTimeOffset = DateTimeOffset.Now.AddDays(-2) }, new CancellationToken()); identityService.Verify(i => i.GetUserNameAsync(UserId), Times.Once); }
public async Task Invoke(HttpContext context) { try { await _next(context); } finally { var request = new RequestLog { Method = context.Request.Method, Path = context.Request.Path.Value, StatusCode = context.Response.StatusCode.ToString(), Host = context.Request.Host.ToString(), Headers = context.Request.Headers.ToString() }; await RequestLogger.Log(request); } }