private RequestResponseLog PrepareResponseLog(RequestResponseLog logData, HttpResponseMessage response) { logData.ResponseStatusCode = response.StatusCode; logData.ResponseTimestamp = DateTime.Now; logData.ResponseContentType = response.Content?.Headers?.ContentType?.MediaType; return(logData); }
public async Task Invoke(HttpContext httpContext, TodoContext dbContext) { var logModel = new RequestResponseLog(); var orginalBody = httpContext.Response.Body; try { await LogRequest(httpContext, logModel); using (var memoryStream = new MemoryStream()) { httpContext.Response.Body = memoryStream; await _next(httpContext); await LogResponse(httpContext, logModel, memoryStream, orginalBody); } await SaveLogModel(dbContext, logModel); } catch (Exception ex) { // Log error _logger.LogError(ex, ex.Message); //allows exception handling middleware to deal with things throw; } finally { httpContext.Response.Body = orginalBody; } }
private async Task <RequestResponseLog> FormatRequest(HttpRequest request) { //This line allows us to set the reader for the request back at the beginning of its stream. request.EnableBuffering(); await using var requestStream = _recyclableMemoryStreamManager.GetStream(); await request.Body.CopyToAsync(requestStream); var requestHeader = new StringBuilder(Environment.NewLine); foreach (var header in request.Headers) { requestHeader.AppendLine($"{header.Key}:{header.Value}"); } logEntity = new RequestResponseLog(); logEntity.Url = $"{request.Host}{request.Path}"; logEntity.RequestHeader = requestHeader.ToString(); logEntity.RequestBody = ReadStreamInChunks(requestStream, Convert.ToInt32(request.ContentLength)); logEntity.QueryString = request.QueryString.HasValue ? request.QueryString.Value : null; logEntity.RequestDate = DateTime.Now; logEntity.TraceId = Activity.Current?.Id ?? request.HttpContext.TraceIdentifier; logEntity.Scheme = request.Scheme; request.Body.Position = 0; return(logEntity); }
public async Task Invoke(HttpContext context) { RequestResponseLog _logInfo = new RequestResponseLog(); var token = context.Request.Headers["Authorization"].ToString().Replace("Bearer ", ""); var users = MemoryCacheManager.GetCache <UserDto>(token); HttpRequest request = context.Request; _logInfo.Url = request.Path.ToString(); IDictionary <string, string> Headers = request.Headers.ToDictionary(k => k.Key, v => string.Join(";", v.Value.ToList())); _logInfo.Headers = $"[" + string.Join(",", Headers.Select(i => "{" + $"\"{i.Key}\":\"{i.Value}\"" + "}")) + "]"; _logInfo.Method = request.Method; _logInfo.ExcuteStartTime = DateTime.Now; _logInfo.UserName = users?.UserName; _logInfo.IPAddress = request.HttpContext.Connection.RemoteIpAddress.ToString(); _logInfo.Port = request.HttpContext.Connection.RemotePort; //获取request.Body内容 if (request.Method.ToLower().Equals("post")) { request.EnableRewind(); //启用倒带功能,就可以让 Request.Body 可以再次读取 Stream stream = request.Body; byte[] buffer = new byte[request.ContentLength.Value]; stream.Read(buffer, 0, buffer.Length); _logInfo.RequestBody = Encoding.UTF8.GetString(buffer); request.Body.Position = 0; } else if (request.Method.ToLower().Equals("get")) { _logInfo.RequestBody = request.QueryString.Value; } using (var responseBody = new MemoryStream()) { //获取Response.Body内容 var originalBodyStream = context.Response.Body; context.Response.Body = responseBody; await _next(context); _logInfo.ResponseBody = await FormatResponse(context.Response); //Log4Net.LogInfo($"VisitLog: {_logInfo.ToString()}"); await responseBody.CopyToAsync(originalBodyStream); } context.Response.OnCompleted(async o => { _logInfo.ExcuteEndTime = DateTime.Now; _appSystemServices.Create <RequestResponseLog>(_logInfo); }, context); }
public ServiceResponse SaveRequestResponselog(RequestResponseLog model, long loggedInUserId) { ServiceResponse response = new ServiceResponse(); response.IsSuccess = true; response.Data = SaveEntity(model, loggedInUserId); return(response); }
//todo: abstrack implementation of log and loglevel private async Task Log(HttpRequest request, HttpResponse response) { //Initialize log var log = new RequestResponseLog(request, response); //And finally, trigger logging await Task.Run(() => _logger.Log(log.LogLevel, "Logging request and response => " + JsonConvert.SerializeObject(log))); }
private RequestResponseLog PrepareRequestLog(HttpRequestMessage request) { RequestResponseLog log = new RequestResponseLog { RequestMethod = request.Method?.Method, RequestTimestamp = DateTime.Now, RequestUri = request?.RequestUri?.ToString() }; return(log); }
public void Insert(RequestResponseLog entity) { try { _context.RequestResponse.Add(entity); _context.SaveChanges(); } catch (Exception ex) { throw; } }
private async Task LogResponse(HttpContext httpContext, RequestResponseLog log, MemoryStream memoryStream, Stream orginalBody) { log.ResponseBody = await GetResponseBody(memoryStream, orginalBody); log.ResponseStatusCode = httpContext.Response.StatusCode; foreach (var header in httpContext.Response.Headers) { log.RequestHeaders += header; } // Log response _logger.LogInformation(log.LogResponse()); }
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext) { long userId = 0; //if (!CheckAllowedActions()) // userId = CacheApiHelper.UserId; #region LogApiResponse //Only For Testing Log Each Request in DB if (ConfigSettings.IsLoggedAPIRequest) { if (actionExecutedContext.Exception != null) { RequestResponseLog requestResponseLog = new RequestResponseLog { Type = "Response", Data = "ERRORRESPONSE:" + Common.SerializeObject(actionExecutedContext.Exception), Url = actionExecutedContext.Request.RequestUri.AbsolutePath, RefRequestResponseLogID = Convert.ToInt64(HttpContext.Current.Request.ServerVariables["RequestResponseLogID"]), UserId = userId }; ITokenDataProvider _tokenDataProvider = new TokenDataProvider(); _tokenDataProvider.SaveRequestResponselog(requestResponseLog, userId); } else { var objectContent = actionExecutedContext.Response.Content as ObjectContent; if (objectContent != null) { //var type = objectContent.ObjectType; //type of the returned object var value = objectContent.Value; //holding the returned value var str = Common.SerializeObject(value); RequestResponseLog requestResponseLog = new RequestResponseLog { Type = "Response", Data = str, Headers = actionExecutedContext.Response.Headers.ToString(), Url = actionExecutedContext.Request.RequestUri.AbsolutePath, RefRequestResponseLogID = Convert.ToInt64(HttpContext.Current.Request.ServerVariables["RequestResponseLogID"]), UserId = userId }; ITokenDataProvider _tokenDataProvider = new TokenDataProvider(); _tokenDataProvider.SaveRequestResponselog(requestResponseLog, userId); } } } #endregion LogApiResponse }
public async Task Invoke(HttpContext httpContext, ITestService testeService) { try { var request = httpContext.Request; var requestResponseLog = new RequestResponseLog(); // PathString("/api") is used to filter just /api routes if (request.Path.StartsWithSegments(new PathString("/api"))) { requestResponseLog.RequestMessage = await ReadRequestBody(request); var originalBodyStream = httpContext.Response.Body; using (var responseBody = new MemoryStream()) { requestResponseLog.RequestDateTime = DateTime.Now; // Execution of the request when call next var response = httpContext.Response; response.Body = responseBody; await _next(httpContext); requestResponseLog.ResponseDateTime = DateTime.Now; requestResponseLog.ResponseMessage = await ReadResponseBody(response); await responseBody.CopyToAsync(originalBodyStream); } requestResponseLog.ResponseCode = httpContext.Response.StatusCode.ToString(); requestResponseLog.Url = $"{httpContext.Request.Scheme}://" + $"{httpContext.Request.Host}{httpContext.Request.Path}{httpContext.Request.QueryString}"; requestResponseLog.Method = httpContext.Request.Method; requestResponseLog.IpAddress = httpContext.Connection.RemoteIpAddress.MapToIPv4().ToString(); testeService.Save(data); } else { await _next(httpContext); } } catch (Exception ex) { await _next(httpContext); } }
private async Task LogRequest(HttpContext httpContext, RequestResponseLog log) { log.RequestBody = await GetRequestBody(httpContext.Request); foreach (var header in httpContext.Request.Headers) { log.RequestHeaders += header; } log.RequestPath = httpContext.Request.Path; log.RequestHost = httpContext.Request.Host.ToString(); log.RequestQueryString = httpContext.Request.QueryString.ToString(); // Log request _logger.LogInformation(log.LogRequest()); }
public ResponseDto <Boolean> Remove([FromBody] RequestResponseLog request) { ResponseDto <Boolean> response = new ResponseDto <Boolean>(); if (string.IsNullOrEmpty(request.Id.ToStringExtension())) { response.Message = "Key 不能为空"; response.Success = false; return(response); } var _entity = _appSystemServices.GetEntitys <RequestResponseLog>(); response.Data = _entity.Where(x => x.Id == request.Id).ToDelete().ExecuteAffrows() > 0; return(response); }
private async Task LogRequest(HttpContext context, IRepositoryByInt <RequestResponseLog> repository) { var request = context.Request; // var controllerActionDescriptor = context.GetEndpoint().Metadata.GetMetadata<ControllerActionDescriptor>(); // var controllerName = controllerActionDescriptor.ControllerName; // var actionName = controllerActionDescriptor.ActionName; var url = request.Path.ToString(); if (request.RouteValues.Count == 0) { return; } var log = new RequestResponseLog(); log.Url = url; log.Method = request.Method; log.Headers = JsonConvert.SerializeObject(request.Headers); log.Createat = DateTime.Now; if (request.Method.Equals("get", StringComparison.InvariantCultureIgnoreCase)) { log.RequestBody = request.QueryString.Value; } else if (request.Method.Equals("post", StringComparison.InvariantCultureIgnoreCase) || request.Method.Equals("put", StringComparison.InvariantCultureIgnoreCase)) { if (request.ContentType == "application/json") { var stream = request.Body; stream.Seek(0, SeekOrigin.Begin); var bytes = new byte[request.ContentLength.Value]; stream.Read(bytes, 0, bytes.Length); log.RequestBody = Encoding.UTF8.GetString(bytes); stream.Seek(0, SeekOrigin.Begin); } } await repository.InsertAsync(log); }
public ResponseDto <RequestResponseLog> Save([FromBody] RequestResponseLog request) { ResponseDto <RequestResponseLog> response = new ResponseDto <RequestResponseLog>(); var _entity = _appSystemServices.GetEntitys <RequestResponseLog>(); if (string.IsNullOrEmpty(request.Id.ToStringExtension()) || request.Id.ToInt32() == 0) { request.SetCreateDefault(this.CurrentUser); _appSystemServices.Create <RequestResponseLog>(request); } else { request.SetModifyDefault(this.CurrentUser); _appSystemServices.Modify <RequestResponseLog>(request); } return(response); }
} //time taken to serve the request public RequestResponseLog ConvertRequestResponseLogDtoToRequestResponse() { RequestResponseLog log = new RequestResponseLog { RequestId = RequestId, IPAddress = IPAddress, Request = new RequestLog { Host = Request.Host, Body = Request.Body, Header = Request.Header, Path = Request.Path, QueryStingBody = Request.QueryStingBody }, Response = new ResponseLog { Body = Response.Body }, TimeInSeconds = TimeInSeconds }; return(log); }
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { RequestResponseLog logData = null; HttpResponseMessage response = null; try { logData = PrepareRequestLog(request); response = await base.SendAsync(request, cancellationToken); logData = PrepareResponseLog(logData, response); } catch (Exception ex) { response = request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex); await SendToLog(ex); } finally { await SendToLog(logData); } return(response); }
public static void SaveRequestResponse(string httpMethodType, string requestBody, DateTime requestTime, string requestUrl, string responseBody, string responseHttpCode, DateTime responseTime) { try { using (var context = new kyc.bridge.api.DataAccess.Model.kycbridgeEntities()) { var rrl = new RequestResponseLog(); rrl.HttpMethodType = httpMethodType; rrl.RequestBody = requestBody; rrl.RequestTime = requestTime; rrl.RequestUrl = requestUrl; rrl.ResponseBody = responseBody; rrl.ResponseHttpCode = responseHttpCode; rrl.ResponseTime = responseTime; context.RequestResponseLogs.Add(rrl); context.SaveChanges(); } } catch (Exception e) { Utils.LogError(e, "Failed to execute SaveRequestResponse"); } }
private async Task SaveLogModel(TodoContext dbContext, RequestResponseLog log) { await dbContext.Logs.AddAsync(log); await dbContext.SaveChangesAsync(); }
public Task PersistAsync(RequestResponseLog log) { return(_context.RequestResponseLogs.InsertOneAsync(log)); }
public override void OnActionExecuting(HttpActionContext actionContext) { long userId = 0; #region LogApiRequest //Only For Testing Log Each Request in DB string filePath = HttpContext.Current.Request.FilePath; if (ConfigSettings.IsLoggedAPIRequest) { if (filePath.Length > 1) { //if (!CheckAllowedActions()) // userId = CacheApiHelper.UserId; var strrequest = string.Empty; var strheaders = string.Empty; if (HttpContext.Current.Request.ContentLength > 0) { HttpContext.Current.Request.InputStream.Position = 0; var inputStream = new StreamReader(HttpContext.Current.Request.InputStream); strrequest = inputStream.ReadToEnd();//actionContext.ActionArguments.Count == 0 ? "NODATA" : Common.SerializeObject(actionContext.ActionArguments[Constants.RequestModelName]); } if (HttpContext.Current.Request.Headers.Count > 0) { strheaders = HttpContext.Current.Request.Headers.ToString(); } var requestResponseLog = new RequestResponseLog { Type = "Request", Data = strrequest, Headers = strheaders, Url = filePath, UserId = userId }; ITokenDataProvider _tokenDataProvider = new TokenDataProvider(); _tokenDataProvider.SaveRequestResponselog(requestResponseLog, userId); HttpContext.Current.Request.ServerVariables["RequestResponseLogID"] = requestResponseLog.RequestResponseLogID.ToString(); } } #endregion if (CacheApiHelper.IsValidKey()) { if (CheckAllowedActions()) { base.OnActionExecuting(actionContext); return; } if (!CacheApiHelper.IsAuthorizedUser()) { Common.SendApiResponse(actionContext, new ServiceResponse { IsSuccess = false, Message = string.Format("'{0}' Header is not passed or invalid.", Constants.KeyHeaderName) }, HttpStatusCode.Unauthorized); } else { base.OnActionExecuting(actionContext); return; } //} //else //{ // Common.BadRequest(Common.ApiBadResponse(new ApiResponse()), actionContext); //} } else { Common.SendApiResponse(actionContext, new ServiceResponse { IsSuccess = false, Message = string.Format("'{0}' Header is not passed or invalid.", Constants.KeyHeaderName) }, HttpStatusCode.NotAcceptable); return; } }
public async Task PersistAsync(RequestResponseLog log) { await _context.RequestResponseLogs.InsertOneAsync(log); }
public void ReceiveRequestResponseLog(RequestResponseLog requestResponseLog) { }