private void RunTestHttp(
string httpMethod, string origin,
string configXml, string json, string requestId, string userAgent, string userHostAddress,
DateTime serverSideTimeUtc, string url,
int expectedResponseCode, Dictionary<string, string> expectedResponseHeaders, List<LogEntry> expectedLogEntries)
{
// Arrange
LogResponse response = new LogResponse();
TestLogger logger = new TestLogger();
CommonTestHelpers.SetConfigCache(configXml, logger);
// Act
LoggerProcessor.ProcessLogRequest(
json,
new LogRequestBase(userAgent, userHostAddress, requestId,url, null, null, null),
serverSideTimeUtc,
httpMethod, origin, response);
// Assert
Assert.Equal(expectedResponseCode, response.StatusCode);
TestLogEntries(expectedLogEntries, logger.LogEntries);
TestResponseHeaders(expectedResponseHeaders, response.Headers);
}
private void ToHttpResponse(LogResponse logResponse, HttpResponse httpResponse)
{
httpResponse.StatusCode = logResponse.StatusCode;
foreach (KeyValuePair<string, string> kvp in logResponse.Headers)
{
httpResponse.AddHeader(kvp.Key, kvp.Value);
}
}
/// <summary>
/// Processes the incoming request. This method is not depended on the environment and so can be unit tested.
/// Note that the incoming request may not be the POST request with log data.
///
/// Effect of this method:
/// * setting StatusCode on the response parameter
/// * adding headers to the response parameter
/// * logging contents of log request
/// </summary>
/// <param name="json">
/// JSON payload in the incoming request
/// </param>
/// <param name="logRequestBase">
/// * Type of browser that sent the request
/// * IP address that sent the address
/// * Url that the request was sent to
/// * Request Id sent as part of the request
/// * Request data to be given to onLogging event handler
/// </param>
/// <param name="serverSideTimeUtc">Current time in UTC</param>
/// <param name="httpMethod">HTTP method of the request</param>
/// <param name="origin">Value of the Origin request header</param>
/// <param name="response">
/// Empty response object. This method can add headers, etc.
/// </param>
internal static void ProcessLogRequest(string json, LogRequestBase logRequestBase,
DateTime serverSideTimeUtc,
string httpMethod, string origin, LogResponse response)
{
JsnlogConfiguration jsnlogConfiguration = JavascriptLogging.GetJsnlogConfiguration();
ILoggingAdapter logger = JavascriptLogging.GetLogger();
if ((httpMethod != "POST") && (httpMethod != "OPTIONS"))
{
response.StatusCode = (int)HttpStatusCode.MethodNotAllowed;
return;
}
string corsAllowedOriginsRegex = jsnlogConfiguration.corsAllowedOriginsRegex;
bool originIsAllowed = ((!string.IsNullOrEmpty(corsAllowedOriginsRegex)) && (!string.IsNullOrEmpty(origin)) && Regex.IsMatch(origin, corsAllowedOriginsRegex));
if (originIsAllowed)
{
response.AppendHeader("Access-Control-Allow-Origin", origin);
}
response.StatusCode = (int)HttpStatusCode.OK;
if (httpMethod == "OPTIONS")
{
// Standard HTTP response (not related to CORS)
response.AppendHeader("Allow", "POST");
// Only if the origin is allowed send CORS headers
if (originIsAllowed)
{
response.AppendHeader("Access-Control-Max-Age", Constants.CorsAccessControlMaxAgeInSeconds.ToString());
response.AppendHeader("Access-Control-Allow-Methods", "POST");
response.AppendHeader("Access-Control-Allow-Headers", "jsnlog-requestid, content-type");
}
return;
}
// httpMethod must be POST
List<FinalLogData> logDatas =
ProcessLogRequestExec(json, logRequestBase, serverSideTimeUtc, jsnlogConfiguration);
// ---------------------------------
// Pass log data to Common Logging
foreach (FinalLogData logData in logDatas)
{
logger.Log(logData);
}
}
private void ProcessRequest(IOwinContext context)
{
var headers = ToDictionary(context.Request.Headers);
string urlReferrer = headers.SafeGet("Referer");
string url = context.Request.Uri.OriginalString;
var logRequestBase = new LogRequestBase(
userAgent: headers.SafeGet("User-Agent"),
userHostAddress: context.Request.RemoteIpAddress,
requestId: headers.GetLogRequestId(),
url: (urlReferrer ?? url).ToString(),
queryParameters: ToDictionary(context.Request.Query),
cookies: Utils.ToDictionary(context.Request.Cookies),
headers: headers);
DateTime serverSideTimeUtc = DateTime.UtcNow;
string httpMethod = context.Request.Method;
string origin = headers.SafeGet("Origin");
Encoding encoding = HttpHelpers.GetEncoding(headers.SafeGet("Content-Type"));
string json;
using (var reader = new StreamReader(context.Request.Body, encoding))
{
json = reader.ReadToEnd();
}
var response = new LogResponse();
LoggerProcessor.ProcessLogRequest(json, logRequestBase,
serverSideTimeUtc,
httpMethod, origin, response);
// Send dummy response. That way, the log request will not remain "pending"
// in eg. Chrome dev tools.
//
// This must be given a MIME type of "text/plain"
// Otherwise, the browser may try to interpret the empty string as XML.
// When the user uses Firefox, and right clicks on the page and chooses "Inspect Element",
// then in that debugger's console it will say "no element found".
// See
// http://www.acnenomor.com/307387p1/how-do-i-setup-my-ajax-post-request-to-prevent-no-element-found-on-empty-response
// http://stackoverflow.com/questions/975929/firefox-error-no-element-found/976200#976200
ToOwinResponse(response, context.Response);
context.Response.ContentType = "text/plain";
context.Response.ContentLength = 0;
}
public void ProcessRequest(HttpContext context)
{
var logRequestBase = new LogRequestBase(
userAgent: context.Request.UserAgent,
userHostAddress: context.GetUserIp(),
requestId: context.GetLogRequestId(),
url: (context.Request.UrlReferrer ?? context.Request.Url).ToString(),
queryParameters: Utils.ToDictionary(context.Request.QueryString),
cookies: ToDictionary(context.Request.Cookies),
headers: Utils.ToDictionary(context.Request.Headers));
DateTime serverSideTimeUtc = DateTime.UtcNow;
string httpMethod = context.Request.HttpMethod;
string origin = context.Request.Headers["Origin"];
string json;
using (var reader = new StreamReader(context.Request.InputStream, context.Request.ContentEncoding))
{
json = reader.ReadToEnd();
}
var logResponse = new LogResponse();
LoggerProcessor.ProcessLogRequest(json, logRequestBase,
serverSideTimeUtc,
httpMethod, origin, logResponse);
// Send dummy response. That way, the log request will not remain "pending"
// in eg. Chrome dev tools.
//
// This must be given a MIME type of "text/plain"
// Otherwise, the browser may try to interpret the empty string as XML.
// When the user uses Firefox, and right clicks on the page and chooses "Inspect Element",
// then in that debugger's console it will say "no element found".
// See
// http://www.acnenomor.com/307387p1/how-do-i-setup-my-ajax-post-request-to-prevent-no-element-found-on-empty-response
// http://stackoverflow.com/questions/975929/firefox-error-no-element-found/976200#976200
HttpResponse httpResponse = context.Response;
ToHttpResponse(logResponse, httpResponse);
httpResponse.ContentType = "text/plain";
httpResponse.ClearContent();
httpResponse.Write("");
}
private void ToOwinResponse(LogResponse logResponse, IOwinResponse owinResponse)
{
owinResponse.StatusCode = logResponse.StatusCode;
foreach (KeyValuePair<string, string> kvp in logResponse.Headers)
{
owinResponse.Headers[kvp.Key] = kvp.Value;
}
}
