private void LogResponse(Logger logger, KissLog.Web.HttpResponse response, ResponseSniffer sniffer)
{
try
{
using (sniffer.MirrorStream)
{
sniffer.MirrorStream.Position = 0;
if (InternalHelpers.PreFilterShouldLogResponseBody(logger, sniffer.MirrorStream, response.Properties))
{
using (TemporaryFile tempFile = new TemporaryFile())
{
using (var fs = File.OpenWrite(tempFile.FileName))
{
sniffer.MirrorStream.CopyTo(fs);
}
string responseFileName = InternalHelpers.ResponseFileName(response.Properties.Headers);
logger.LogFile(tempFile.FileName, responseFileName);
}
}
}
}
catch (Exception ex)
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Error logging HTTP Response Content as file");
sb.AppendLine(ex.ToString());
KissLog.Internal.InternalHelpers.Log(sb.ToString(), LogLevel.Error);
}
}
public static WebRequestProperties Create(HttpRequest request)
{
WebRequestProperties result = new WebRequestProperties();
if (request == null)
{
return(result);
}
result.StartDateTime = DateTime.UtcNow;
result.UserAgent = request.UserAgent;
result.Url = request.Url;
result.HttpMethod = request.HttpMethod;
result.HttpReferer = request.UrlReferrer?.AbsolutePath;
result.RemoteAddress = request.UserHostAddress;
result.MachineName = GetMachineName(request);
RequestProperties requestProperties = new RequestProperties();
result.Request = requestProperties;
var headers = DataParser.ToDictionary(request.Unvalidated.Headers);
headers = FilterHeaders(headers);
var queryString = DataParser.ToDictionary(request.Unvalidated.QueryString);
var formData = DataParser.ToDictionary(request.Unvalidated.Form);
var serverVariables = DataParser.ToDictionary(request.ServerVariables);
serverVariables = FilterServerVariables(serverVariables);
var cookies = DataParser.ToDictionary(request.Unvalidated.Cookies);
requestProperties.Headers = headers;
requestProperties.QueryString = queryString;
requestProperties.FormData = formData;
requestProperties.ServerVariables = serverVariables;
requestProperties.Cookies = cookies;
string inputStream = null;
if (InternalHelpers.ShouldLogInputStream(headers))
{
inputStream = ReadInputStream(request);
}
requestProperties.InputStream = inputStream;
return(result);
}
public static HttpRequest Create(System.Web.HttpRequestBase httpRequest)
{
if (httpRequest == null)
{
throw new ArgumentNullException(nameof(httpRequest));
}
HttpRequest result = new HttpRequest(new HttpRequest.CreateOptions
{
Url = httpRequest.Url,
HttpMethod = httpRequest.HttpMethod,
UserAgent = httpRequest.UserAgent,
HttpReferer = httpRequest.UrlReferrer?.ToString(),
RemoteAddress = httpRequest.UserHostAddress,
MachineName = InternalHelpers.GetMachineName(httpRequest)
});
RequestProperties.CreateOptions propertiesOptions = new RequestProperties.CreateOptions();
propertiesOptions.ServerVariables = InternalHelpers.ToKeyValuePair(httpRequest.ServerVariables);
if (httpRequest.Unvalidated != null)
{
propertiesOptions.Headers = InternalHelpers.ToKeyValuePair(httpRequest.Unvalidated.Headers);
propertiesOptions.Cookies = InternalHelpers.ToKeyValuePair(httpRequest.Unvalidated.Cookies);
propertiesOptions.QueryString = InternalHelpers.ToKeyValuePair(httpRequest.Unvalidated.QueryString);
if (KissLogConfiguration.Options.Handlers.ShouldLogFormData.Invoke(result) == true)
{
propertiesOptions.FormData = InternalHelpers.ToKeyValuePair(httpRequest.Unvalidated.Form);
}
}
if (KissLog.InternalHelpers.CanReadRequestInputStream(propertiesOptions.Headers))
{
if (KissLogConfiguration.Options.Handlers.ShouldLogInputStream.Invoke(result) == true)
{
propertiesOptions.InputStream = KissLog.InternalHelpers.WrapInTryCatch(() =>
{
return(InternalHelpers.ReadInputStream(httpRequest));
});
}
}
result.SetProperties(new RequestProperties(propertiesOptions));
return(result);
}
internal void OnPostAuthenticateRquest(HttpContextBase httpContext)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
var factory = new LoggerFactory();
Logger logger = factory.GetInstance(httpContext);
if (logger.DataContainer.HttpProperties == null && httpContext.Request != null)
{
KissLog.Http.HttpRequest httpRequest = HttpRequestFactory.Create(httpContext.Request);
logger.DataContainer.SetHttpProperties(new Http.HttpProperties(httpRequest));
}
if (logger.DataContainer.HttpProperties == null)
{
return;
}
bool isAuthenticated = httpContext.User?.Identity?.IsAuthenticated ?? false;
logger.DataContainer.HttpProperties.Request.SetIsAuthenticated(isAuthenticated);
if (httpContext.User == null || httpContext.User is ClaimsPrincipal == false)
{
return;
}
ClaimsPrincipal claimsPrincipal = httpContext.User as ClaimsPrincipal;
if (claimsPrincipal.Identity == null || claimsPrincipal.Identity is ClaimsIdentity == false)
{
return;
}
ClaimsIdentity claimsIdentity = claimsPrincipal.Identity as ClaimsIdentity;
List <KeyValuePair <string, string> > claims = InternalHelpers.ToKeyValuePair(claimsIdentity);
logger.DataContainer.HttpProperties.Request.Properties.SetClaims(claims);
}
public static HttpResponse Create(System.Web.HttpResponseBase httpResponse, long contentLength)
{
if (httpResponse == null)
{
throw new ArgumentNullException(nameof(httpResponse));
}
if (contentLength < 0)
{
throw new ArgumentException(nameof(contentLength));
}
var options = new HttpResponse.CreateOptions();
options.StatusCode = httpResponse.StatusCode;
options.Properties = new ResponseProperties(new ResponseProperties.CreateOptions
{
Headers = InternalHelpers.ToKeyValuePair(httpResponse.Headers),
ContentLength = contentLength
});
return(new HttpResponse(options));
}
private void EndRequest(object sender, EventArgs e)
{
HttpContext ctx = HttpContext.Current;
Logger logger = Logger.Factory.Get() as Logger;
if (logger == null)
{
return;
}
Exception ex = ctx.Server.GetLastError();
if (ex != null)
{
logger.Log(LogLevel.Error, ex);
}
var sniffer = ctx.Response.Filter as ResponseSniffer;
if (ctx.Response.StatusCode >= 400 && ex == null)
{
if (sniffer != null)
{
string responseContent = null;
try
{
responseContent = sniffer.GetContent();
}
catch (Exception ex1)
{
InternalHelpers.Log(ex1.ToString(), LogLevel.Error);
}
if (string.IsNullOrEmpty(responseContent) == false)
{
logger.Log(LogLevel.Error, responseContent);
}
}
}
WebProperties webProperties = (WebProperties)HttpContext.Current.Items[Constants.HttpRequestPropertiesKey];
if (webProperties == null)
{
// IIS redirect bypasses the BeginRequest() event
webProperties = new WebProperties
{
Request = HttpRequestFactory.Create(ctx.Request)
};
}
KissLog.Web.HttpResponse response = HttpResponseFactory.Create(ctx.Response);
webProperties.Response = response;
if (logger.DataContainer.ExplicitHttpStatusCode.HasValue)
{
response.HttpStatusCode = logger.DataContainer.ExplicitHttpStatusCode.Value;
}
if (sniffer != null)
{
response.Properties.ContentLength = ReadResponseLength(sniffer);
LogResponse(logger, response, sniffer);
}
logger.DataContainer.WebProperties = webProperties;
IEnumerable <ILogger> loggers = Logger.Factory.GetAll();
Logger.NotifyListeners(loggers.ToArray());
}
private void EndRequest(object sender, EventArgs e)
{
HttpContext ctx = HttpContext.Current;
Logger logger = Logger.Factory.Get() as Logger;
if (logger == null)
{
return;
}
Exception ex = ctx.Server.GetLastError();
if (ex != null)
{
logger.Log(LogLevel.Error, ex);
}
var sniffer = ctx.Response.Filter as ResponseSniffer;
if (ctx.Response.StatusCode >= 400 && ex == null)
{
if (sniffer != null)
{
string responseContent = sniffer.GetContent();
if (string.IsNullOrEmpty(responseContent) == false)
{
logger.Log(LogLevel.Error, responseContent);
}
}
}
WebRequestProperties properties = (WebRequestProperties)HttpContext.Current.Items[Constants.HttpRequestPropertiesKey];
properties.EndDateTime = DateTime.UtcNow;
ResponseProperties response = WebResponsePropertiesFactory.Create(ctx.Response);
properties.Response = response;
if (logger.DataContainer.ExplicitHttpStatusCode.HasValue)
{
response.HttpStatusCode = logger.DataContainer.ExplicitHttpStatusCode.Value;
}
if (sniffer != null)
{
response.ContentLength = sniffer.MirrorStream.Length;
}
if (sniffer != null)
{
using (sniffer.MirrorStream)
{
sniffer.MirrorStream.Position = 0;
if (InternalHelpers.PreFilterShouldLogResponseBody(logger, sniffer.MirrorStream, response))
{
using (TemporaryFile tempFile = new TemporaryFile())
{
using (var fs = File.OpenWrite(tempFile.FileName))
{
sniffer.MirrorStream.CopyTo(fs);
}
string responseFileName = InternalHelpers.ResponseFileName(properties.Response.Headers);
logger.LogFile(tempFile.FileName, responseFileName);
}
}
}
}
logger.DataContainer.WebRequestProperties = properties;
IEnumerable <ILogger> loggers = Logger.Factory.GetAll();
Logger.NotifyListeners(loggers.ToArray());
}
