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)
{
}
