public async Task Invoke(HttpContext context)
{
var model = new RequestProfilerModel
{
RequestTime = new DateTimeOffset(),
Context = context,
Request = await FormatRequest(context)
};
Stream originalBody = context.Response.Body;
using (MemoryStream newResponseBody = _recyclableMemoryStreamManager.GetStream())
{
context.Response.Body = newResponseBody;
await _next(context);
newResponseBody.Seek(0, SeekOrigin.Begin);
await newResponseBody.CopyToAsync(originalBody);
newResponseBody.Seek(0, SeekOrigin.Begin);
model.Response = FormatResponse(context, newResponseBody);
model.ResponseTime = new DateTimeOffset();
_requestResponseHandler(model);
}
}
public async Task Invoke(HttpContext context)
{
var token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
if (token != null)
{
attachAccountToContext(context, token);
}
// await _next(context);
var model = new RequestProfilerModel
{
RequestTime = new DateTimeOffset(),
Context = context,
Request = await FormatRequest(context)
};
Stream originalBody = context.Response.Body;
using (MemoryStream newResponseBody = _recyclableMemoryStreamManager.GetStream())
{
context.Response.Body = newResponseBody;
await _next(context);
newResponseBody.Seek(0, SeekOrigin.Begin);
await newResponseBody.CopyToAsync(originalBody);
newResponseBody.Seek(0, SeekOrigin.Begin);
model.Response = FormatResponse(context, newResponseBody);
model.ResponseTime = new DateTimeOffset();
_requestResponseHandler(model);
}
}
public void Log(RequestProfilerModel model)
{
if (model.StatusCode >= 300 || model.StatusCode < 200)
{
_logger.LogError(string.Format(errorFormat, model.RequestTime, model.StatusCode, model.ResponseTime, model.Method, model.Path, model.QueryString, model.RequestContent, model.ResponseContent, model.CorrelationId));
}
else
{
_logger.LogInformation(string.Format(infoFormat, model.RequestTime, model.ResponseTime, model.Method, model.Path, model.QueryString));
}
}
public async Task Invoke(HttpContext context)
{
var stopwatch = System.Diagnostics.Stopwatch.StartNew();;
var model = new RequestProfilerModel
{
Context = context,
Request = FormatRequest(context)
};
await _next(context);
stopwatch.Stop();
model.Duration = stopwatch.ElapsedMilliseconds;
model.Status = context.Response.StatusCode;
_requestResponseHandler(model);
}
public static void WriteRequestLog(RequestProfilerModel requestObject, string connString, bool isProdVersion, bool logContentObject)
{
Logger logger = LogManager.GetLogger("requestLog");
var builder = new StringBuilder(Environment.NewLine);
GlobalDiagnosticsContext.Set("ClientIp", requestObject.Context.Connection.RemoteIpAddress.ToString());
GlobalDiagnosticsContext.Set("Logger", "OnlineBankingApi");
GlobalDiagnosticsContext.Set("CallMethod", requestObject.Context.Request.Host.Value + requestObject.Context.Request.Path.Value);
GlobalDiagnosticsContext.Set("Request", requestObject.Request);
GlobalDiagnosticsContext.Set("Response", requestObject.Response);
string logJson = "";
if (logContentObject)
{
logJson = requestObject.Request + requestObject.Response;
}
else
{
var response = Newtonsoft.Json.JsonConvert.DeserializeObject <Response>(requestObject.Response);
logJson = Newtonsoft.Json.JsonConvert.SerializeObject(response);
}
GlobalDiagnosticsContext.Set("Json", logJson);
Parallel.ForEach(requestObject.Context.Request.Headers, x =>
{
if (!(isProdVersion && x.Key == "SessionId"))
{
builder.AppendLine($"{x.Key}:{x.Value}");
}
});
GlobalDiagnosticsContext.Set("Headers", builder.ToString());
GlobalDiagnosticsContext.Set("UserName", "----");
var databaseTarget = (DatabaseTarget)LogManager.Configuration.FindTargetByName("RequestDatabase");
databaseTarget.ConnectionString = connString;
LogManager.ReconfigExistingLoggers();
logger.Info("Request Logger");
}
public async Task Invoke(HttpContext context, ILogger <ApiLoggingMiddleware> logger)
{
_logger = logger;
var request = context.Request;
var model = new RequestProfilerModel
{
RequestTime = DateTime.Now,
Method = request.Method,
Path = request.Path,
QueryString = request.QueryString.ToString(),
RequestContent = await GetRequestBody(request),
};
context.Response.OnCompleted(async() =>
{
context.Response.Headers.TryGetValue("X-Correlation-ID", out StringValues colId);
model.CorrelationId = colId.ToString();
Log(model);
});
Stream originalBody = context.Response.Body;
using (MemoryStream newResponseBody = _recyclableMemoryStreamManager.GetStream())
{
context.Response.Body = newResponseBody;
var sb = new Stopwatch();
sb.Start();
await _next(context);
sb.Stop();
model.ResponseTime = sb.ElapsedMilliseconds;
model.StatusCode = context.Response.StatusCode;
newResponseBody.Seek(0, SeekOrigin.Begin);
await newResponseBody.CopyToAsync(originalBody);
newResponseBody.Seek(0, SeekOrigin.Begin);
model.ResponseContent = ReadStreamInChunks(newResponseBody);
}
}
public async Task Invoke(HttpContext context)
{
string remoteIpAddress = context.Request.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString();
if (context.Request.Headers.ContainsKey("X-Forwarded-For"))
{
remoteIpAddress = context.Request.Headers["X-Forwarded-For"];
}
string.Join(" ", context.Request.Headers);
var conn = string.Join("", context.Request.HttpContext.Connection.RemoteIpAddress.MapToIPv4().ToString());
Log.Information("Client details headers {IP}, {Headers}", remoteIpAddress, conn);
var model = new RequestProfilerModel
{
RequestTime = new DateTimeOffset(),
Context = context,
Request = await FormatRequest(context)
};
Stream originalBody = context.Response.Body;
using (MemoryStream newResponseBody = _recyclableMemoryStreamManager.GetStream())
{
context.Response.Body = newResponseBody;
await _next(context);
newResponseBody.Seek(0, SeekOrigin.Begin);
String response = LocalEncoding.GetString(newResponseBody.ToArray());
string code = ResponseCodesList.Success;
string message = "Successful";
KoboWashResult newBody = JsonConvert.DeserializeObject <KoboWashResult>(response);
Object data = null;
if (newBody.ResponseCode != null)
{
code = newBody.ResponseCode;
message = newBody.ResponseMessage;
}
else
{
data = JsonConvert.DeserializeObject(response);
}
KoboWashResult res = new KoboWashResult(code, message)
{
Data = data
};
String result = JsonConvert.SerializeObject(res);
_logger.Log(LogLevel.Information, result);
byte[] byteArray = Encoding.ASCII.GetBytes(result);
MemoryStream stream = new MemoryStream(byteArray);
await stream.CopyToAsync(originalBody);
stream.Seek(0, SeekOrigin.Begin);
model.Response = FormatResponse(context, stream);
model.ResponseTime = new DateTimeOffset();
_requestResponseHandler(model);
}
}
private void LogEvent(RequestProfilerModel requestProfilerModel)
{
_logger.LogInformation(JsonConvert.SerializeObject(requestProfilerModel.Request));
_logger.LogInformation(JsonConvert.SerializeObject(requestProfilerModel.Response));
}
public async Task Invoke(HttpContext context)
{
bool isProdVersion = !Convert.ToBoolean(_config["TestVersion"]);
if (isProdVersion)
{
try
{
var controllerName = this.GetControllerName(context.Request.Path.Value);
var crnControllContext = Type.GetType(controllerName);
var containsAttribute = crnControllContext.CustomAttributes.Any(attr => attr.AttributeType == typeof(LoggerOff));
if (containsAttribute)
{
await this._next.Invoke(context);
return;
}
var actionName = this.GetActionName(context.Request.Path.Value);
var action = crnControllContext.GetMethod(actionName);
containsAttribute = action.CustomAttributes.Any(attr => attr.AttributeType == typeof(LoggerOff));
if (containsAttribute)
{
await this._next.Invoke(context);
return;
}
}
catch
{
await this._next.Invoke(context);
return;
}
}
var model = new RequestProfilerModel
{
RequestTime = new DateTimeOffset(),
Context = context,
Request = await FormatRequest(context)
};
Stream originalBody = context.Response.Body;
using (MemoryStream newResponseBody = _recyclableMemoryStreamManager.GetStream())
{
context.Response.Body = newResponseBody;
await _next(context);
newResponseBody.Seek(0, SeekOrigin.Begin);
await newResponseBody.CopyToAsync(originalBody);
newResponseBody.Seek(0, SeekOrigin.Begin);
model.Response = FormatResponse(context, newResponseBody);
model.ResponseTime = new DateTimeOffset();
_requestResponseHandler(model);
}
}
