private string AppendPropertyQuery(ResponseProperties properties)
{
string queryParameter = "";
queryParameter += string.Format("LIMIT {0},{1}", (properties.pageNumber * properties.pageSize), properties.pageSize);
return(queryParameter);
}
public static ResponseProperties Create(HttpResponse response)
{
ResponseProperties result = new ResponseProperties();
if (response == null)
{
return(result);
}
result.HttpStatusCode = (HttpStatusCode)response.StatusCode;
foreach (string key in response.Headers.Keys)
{
StringValues values;
response.Headers.TryGetValue(key, out values);
string value = values.ToString();
result.Headers.Add(
new KeyValuePair <string, string>(key, value)
);
}
return(result);
}
public void CloneCopiesAllTheProperties()
{
ResponseProperties item = CommonTestHelpers.Factory.CreateResponseProperties();
ResponseProperties clone = item.Clone();
Assert.AreEqual(JsonSerializer.Serialize(item), JsonSerializer.Serialize(clone));
}
public void HeadersIsNotNull()
{
ResponseProperties item = new ResponseProperties(new ResponseProperties.CreateOptions
{
Headers = null
});
Assert.IsNotNull(item.Headers);
}
public List <Photo> GetAll(ResponseProperties properties)
{
string query = string.Format("Select * from {0} ", tableName);
query += AppendPropertyQuery(properties);
DataTable entityReturned = _connection.ExecuteQueryGet(query);
return(mapper.FromDb(entityReturned));
}
public void NegativeContentLengthThrowsException()
{
var options = new ResponseProperties.CreateOptions
{
Headers = CommonTestHelpers.GenerateList(2),
ContentLength = -1
};
ResponseProperties item = new ResponseProperties(options);
}
public void NullKeyValuesAreNotCopied(string keyName)
{
var options = new ResponseProperties.CreateOptions
{
Headers = CommonTestHelpers.GenerateList(keyName, 2),
ContentLength = 10000
};
ResponseProperties item = new ResponseProperties(options);
Assert.AreEqual(0, item.Headers.Count());
}
public void CreateOptionsConstructorUpdatesProperties()
{
var options = new ResponseProperties.CreateOptions
{
Headers = CommonTestHelpers.GenerateList(2),
ContentLength = 10000
};
ResponseProperties item = new ResponseProperties(options);
Assert.AreEqual(JsonSerializer.Serialize(options.Headers), JsonSerializer.Serialize(item.Headers));
Assert.AreEqual(options.ContentLength, item.ContentLength);
}
public HttpResponseMessage GetAll([FromUri] int PageNumber = 0, [FromUri] int PageSize = 10)
{
ResponseProperties properties = new ResponseProperties()
{
pageNumber = PageNumber,
pageSize = PageSize
};
List <Photo> photos = _service.GetAll(properties);
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK, photos);
return(response);
}
public static ResponseProperties Create(HttpResponse response)
{
ResponseProperties result = new ResponseProperties();
if (response == null)
{
return(result);
}
result.HttpStatusCode = (HttpStatusCode)response.StatusCode;
result.Headers = DataParser.ToDictionary(response.Headers);
return(result);
}
internal static HttpProperties Create(KissLog.Http.HttpProperties httpProperties)
{
if (httpProperties == null)
{
throw new ArgumentNullException(nameof(httpProperties));
}
Url url = Create(httpProperties.Request.Url);
RequestProperties requestProperties = Create(httpProperties.Request.Properties);
ResponseProperties responseProperties = Create(httpProperties.Response);
return(new HttpProperties
{
Url = url,
UserAgent = httpProperties.Request.UserAgent,
HttpMethod = httpProperties.Request.HttpMethod,
HttpReferer = httpProperties.Request.HttpReferer,
RemoteAddress = httpProperties.Request.RemoteAddress,
Request = requestProperties,
Response = responseProperties
});
}
public void NullCreateOptionsThrowsException()
{
ResponseProperties item = new ResponseProperties(null);
}
public static bool PreFilterShouldLogResponseBody(Logger defaultLogger, Stream responseStream, ResponseProperties response)
{
// could add more restrictions, like Content-Type: ["text/plain", "application/json"]
if (responseStream == null || responseStream.CanRead == false)
{
return(false);
}
if (responseStream.Length > LoggerFileMaximumSizeBytes)
{
return(false);
}
var logResponse = defaultLogger.DataContainer.GetProperty(LogResponseBodyProperty);
if (logResponse != null && logResponse is bool asBoolean)
{
return(asBoolean);
}
return(true);
}
public static bool PreFilterShouldLogResponseBody(Logger defaultLogger, TemporaryFile responseBodyFile, ResponseProperties response)
{
// could add more restrictions, like Content-Type: ["text/plain", "application/json"]
if (string.IsNullOrEmpty(responseBodyFile?.FileName))
{
return(false);
}
FileInfo fi = new FileInfo(responseBodyFile.FileName);
if (!fi.Exists || fi.Length > LoggerFileMaximumSizeBytes)
{
return(false);
}
var logResponse = defaultLogger.DataContainer.GetProperty(LogResponseBodyProperty);
if (logResponse != null && logResponse is bool asBoolean)
{
return(asBoolean);
}
return(true);
}
public List <Photo> GetAll(ResponseProperties properties)
{
return(photoRepository.GetAll(properties));
}
public async Task Invoke(HttpContext context)
{
Logger logger = Logger.Factory.Get() as Logger;
if (logger == null)
{
return;
}
logger.DataContainer.AddProperty(InternalHelpers.IsCreatedByHttpRequest, true);
WebRequestProperties properties = WebRequestPropertiesFactory.Create(context.Request);
Exception ex = null;
Stream originalBodyStream = context.Response.Body;
TemporaryFile responseBodyFile = null;
long contentLength = 0;
try
{
using (var responseStream = new MemoryStream())
{
context.Response.Body = responseStream;
await _next(context);
responseBodyFile = new TemporaryFile();
await ReadResponse(context.Response, responseBodyFile.FileName);
contentLength = responseStream.Length;
if (CanWriteToResponseBody(context.Response))
{
await responseStream.CopyToAsync(originalBodyStream);
}
}
}
catch (Exception e)
{
ex = e;
throw;
}
finally
{
context.Response.Body = originalBodyStream;
properties.EndDateTime = DateTime.UtcNow;
HttpStatusCode statusCode = (HttpStatusCode)context.Response.StatusCode;
if (ex != null)
{
statusCode = HttpStatusCode.InternalServerError;
logger.Log(LogLevel.Error, ex);
}
if (logger.DataContainer.ExplicitHttpStatusCode.HasValue)
{
statusCode = logger.DataContainer.ExplicitHttpStatusCode.Value;
}
ResponseProperties response = ResponsePropertiesFactory.Create(context.Response);
response.HttpStatusCode = statusCode;
response.ContentLength = contentLength;
properties.Response = response;
if (responseBodyFile != null && InternalHelpers.PreFilterShouldLogResponseBody(logger, responseBodyFile, response))
{
string responseFileName = InternalHelpers.ResponseFileName(response.Headers);
logger.LogFile(responseBodyFile.FileName, responseFileName);
}
logger.DataContainer.WebRequestProperties = properties;
responseBodyFile?.Dispose();
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());
}
