public void Log_Should_Write_To_SystemConsole()
{
var requestData = new RequestData();
var responseData = new ResponseData();
_requestLogger.Log(requestData, responseData);
_systemConsole.Verify(x => x.WriteLine(It.IsAny <string>(), It.IsAny <object[]>()), Times.Exactly(8));
}
public override async Task Invoke(IOwinContext context)
{
var requestData = new RequestData();
var responseData = new ResponseData();
var requestStream = await CreateSeekableStream(context.Request.Body);
var responseStream = context.Response.Body;
context.Request.Body = requestStream;
using (var copyStream = new MemoryStream())
{
try
{
context.Response.Body = copyStream;
requestData = GetRequestData(context.Request);
await Next.Invoke(context);
responseData = GetResponseData(context.Response);
_requestLogger.Log(requestData, responseData);
}
catch (Exception ex)
{
_requestLogger.LogError(requestData, responseData, ex);
}
requestStream.Seek(0, SeekOrigin.Begin);
copyStream.Seek(0, SeekOrigin.Begin);
await copyStream.CopyToAsync(responseStream);
}
}
public async Task InvokeAsync(HttpContext context, IRequestLogger logger)
{
context.Request.EnableBuffering();
if (context.Request != null)
{
string path = context.Request.Path;
var method = context.Request.Method;
var queryString = context.Request.QueryString.ToString();
string bodyString;
using (var reader = new StreamReader(context.Request.Body, Encoding.UTF8, true, 1024, true))
{
bodyString = await reader.ReadToEndAsync();
}
context.Request.Body.Seek(0, SeekOrigin.Begin);
logger.Log(method, path, queryString, bodyString);
}
if (_next != null)
{
await _next(context);
}
}
private static Action <NancyContext> GetLogRequestHook(IRequestLogger requestLogger)
{
return(ctx =>
{
var requestData = ExtractRequestData(ctx.Request);
var responseData = ExtractResponseData(ctx.Response);
requestLogger.Log(requestData, responseData);
});
}
public override void OnEndRequest(HttpContextBase context)
{
if (ShouldNotLog(context.Request))
{
return;
}
var requestData = ExtractRequestData(context.Request);
var responseData = ExtractResponseData(context.Response);
_requestLogger.Log(requestData, responseData);
}
/// <summary>
/// Easy way to log all requests
/// </summary>
/// <param name="requestDto"></param>
protected void OnEachRequest(object requestDto)
{
if (this.RequestLogger == null)
{
return;
}
try
{
RequestLogger.Log(this.RequestContext, requestDto);
}
catch (Exception ex)
{
Log.Error("Error while logging request: " + requestDto.Dump(), ex);
}
}
/// <summary>
/// Filter called after each request. Lets you change the response type
/// </summary>
/// <param name="requestDto"></param>
/// <param name="response"></param>
/// <returns></returns>
protected object AfterEachRequest <TRequest>(TRequest requestDto, object response)
{
if (this.RequestLogger != null)
{
try
{
RequestLogger.Log(this.RequestContext, requestDto, response, requestDurationStopwatch.Elapsed);
}
catch (Exception ex)
{
Log.Error("Error while logging request: " + requestDto.Dump(), ex);
}
}
return(response.IsErrorResponse() ? response : OnAfterExecute(response)); //only call OnAfterExecute if no exception occured
}
private void Context_EndRequest(object sender, EventArgs e)
{
string extension = VirtualPathUtility.GetExtension(this._httpContextProvider.Url.LocalPath);
if (StaticResourceExtensions.Contains(extension))
{
return;
}
if (_settingManager.GetContainer <AppSetting>().Contains("RequestLoggingEnabled") &&
bool.Parse(_settingManager.GetContainer <AppSetting>()["RequestLoggingEnabled"].Value))
{
Stopwatch stopwatch = (Stopwatch)_httpContextProvider.Items["Stopwatch"];
if (stopwatch == null)
{
return;
}
stopwatch.Stop();
TimeSpan ts = stopwatch.Elapsed;
RequestLog requestLog = new RequestLog();
requestLog.AbsolutePath = _httpContextProvider.Url.AbsolutePath;
requestLog.BrowserType = _httpContextProvider.BrowserType;
requestLog.ClientIP = _httpContextProvider.ClientIP;
if (_httpContextProvider.Items.Contains("CountryInfo") && _httpContextProvider.Items["CountryInfo"] != null)
{
requestLog.CountryCode = ((Country)_httpContextProvider.Items["CountryInfo"]).Key;
}
requestLog.CreatedBy = _httpContextProvider.UserName;
requestLog.Duration = (int)ts.TotalMilliseconds;
requestLog.HttpMethod = _httpContextProvider.HttpMethod;
requestLog.QueryString = _httpContextProvider.Url.Query;
requestLog.SessionID = (string)_httpContextProvider.Items["SessionId"];
requestLog.UserAgent = _httpContextProvider.ServerVariables["HTTP_USER_AGENT"];
_requestLogger.Log(requestLog);
_httpContextProvider.Items["Stopwatch"] = null;
_httpContextProvider.Items["SessionId"] = null;
_httpContextProvider.Items["CountryInfo"] = null;
}
}
public async Task <CommandResult> Handle(TCommand command, RequestContext context)
{
CommandResult result = null;
DateTime requestDate = DateTime.UtcNow;
using (logger.BeginScope($"trace-id:{context.TraceId}"))
try
{
result = await decoratedRequestHandler.Handle(command, context);
}
catch (Exception ex)
{
result = new CommandResult(new Failure(Constants.UnhandledException, ex.ToString()));
}
finally
{
var commandName = command.GetType().Name;
bool shouldLog = logSettings?.ShouldLog(commandName) ?? true;
if (shouldLog)
{
requestLogger.Log(new RequestLog
{
Name = commandName,
CorrelationId = context.TraceId,
Request = command,
RequestDate = requestDate,
Response = result,
ResponseDate = DateTime.UtcNow,
Result = result.HasError ? Result.Error : Result.Success
//UserCode = context.CorrelationContext.UserId
});
}
}
return(result);
}
public async Task <QueryResult <TResponse> > Handle(TQuery query, RequestContext context)
{
QueryResult <TResponse> result = null;
DateTime requestDate = DateTime.UtcNow;
using (logger.BeginScope($"trace-id:{context.TraceId}"))
try
{
result = await decoratedRequestHandler.Handle(query, context);
}
catch (Exception ex)
{
result = new QueryResult <TResponse>(new Failure(Constants.UnhandledException, ex.ToString()));
}
finally
{
var queryName = query.GetType().Name;
var logSetting = logSettings.Settings?.FirstOrDefault(x => x.Name == queryName);
if (logSetting == null || logSetting.ShouldLog)
{
await requestLogger.Log(new RequestLog
{
Name = queryName,
CorrelationId = context.TraceId,
Request = logSetting?.LogRequest ?? true ? query : null,
RequestDate = requestDate,
Response = logSetting?.LogResponse ?? true ? result : new { result.Code, result.Errors, result.HasError, result.IsSuccess, result.Message, result.Retry },
ResponseDate = DateTime.UtcNow,
Result = result.HasError ? Result.Error : Result.Success,
UserCode = context.UserId
});
}
}
return(result);
}
/// <summary>
/// Executes a REST request indirectly via a callback function <paramref name="executeCallback"/>,
/// and using a user-defined callback function <paramref name="responseBuilderCallback"/> for
/// constructing the resulting <see cref="Response"/> object.
/// </summary>
/// <remarks>
/// The callback method <paramref name="executeCallback"/> is responsible for setting the body
/// of the request, if any, before executing the request. The callback method returns a string
/// representation of the body of the final request when available, otherwise returns a string
/// indicating the body is no longer available (e.g. was sent as a stream, or is binary). The
/// result is only required for passing as an argument to <see cref="IRequestLogger.Log"/>.
///
/// <para>The Boolean argument to <paramref name="responseBuilderCallback"/> indicates whether
/// or not an exception was thrown while executing the request. The value is <c>true</c>
/// if an exception occurred, otherwise <c>false</c>.</para>
/// </remarks>
/// <param name="url">The base URI.</param>
/// <param name="method">The HTTP method to use for the request.</param>
/// <param name="responseBuilderCallback">A user-specified function used to construct the resulting <see cref="Response"/>
/// object from the <see cref="HttpWebResponse"/> and a Boolean value specifying whether or not a <see cref="WebException"/>
/// was thrown during the request. If this value is <c>null</c>, a default method is used to construct
/// the resulting <see cref="Response"/> object.</param>
/// <param name="headers">
/// A collection of custom HTTP headers to include with the request. If the value is
/// <c>null</c>, no custom headers are added to the HTTP request.
/// </param>
/// <param name="queryStringParameters">
/// A collection of parameters to add to the query string portion of the request URI.
/// If the value is <c>null</c>, no parameters are added to the query string.
/// </param>
/// <param name="settings">
/// The settings to use for the request. If the value is <c>null</c>, the default settings returned
/// by <see cref="DefaultRequestSettings"/> will be used for the request.
/// </param>
/// <param name="executeCallback"></param>
/// <returns>Returns a <see cref="Response"/> object containing the HTTP status code, headers,
/// and body from the REST response.</returns>
/// <exception cref="ArgumentNullException">
/// If <paramref name="url"/> is <c>null</c>.
/// <para>-or-</para>
/// <para>If <paramref name="executeCallback"/> is <c>null</c>.</para>
/// </exception>
/// <exception cref="NotSupportedException">If <paramref name="method"/> is not supported by the service.</exception>
public virtual Response ExecuteRequest(Uri url, HttpMethod method, Func <HttpWebResponse, bool, Response> responseBuilderCallback, Dictionary <string, string> headers, Dictionary <string, string> queryStringParameters, RequestSettings settings, Func <HttpWebRequest, string> executeCallback)
{
if (url == null)
{
throw new ArgumentNullException("url");
}
if (executeCallback == null)
{
throw new ArgumentNullException("executeCallback");
}
url = _urlBuilder.Build(url, queryStringParameters);
if (settings == null)
{
settings = DefaultRequestSettings;
}
return(_retryLogic.Execute(() =>
{
Response response;
var startTime = DateTimeOffset.UtcNow;
string requestBodyText = null;
try
{
var req = WebRequest.Create(url) as HttpWebRequest;
req.Method = method.ToString();
req.ContentType = settings.ContentType;
req.Accept = settings.Accept;
req.AllowAutoRedirect = settings.AllowAutoRedirect;
if (settings.ContentLength > 0 || settings.AllowZeroContentLength)
{
req.ContentLength = settings.ContentLength;
}
if (settings.ConnectionLimit != null)
{
req.ServicePoint.ConnectionLimit = settings.ConnectionLimit.Value;
}
req.Timeout = (int)settings.Timeout.TotalMilliseconds;
if (!string.IsNullOrEmpty(settings.UserAgent))
{
req.UserAgent = settings.UserAgent;
}
if (settings.Credentials != null)
{
req.Credentials = settings.Credentials;
}
if (headers != null)
{
foreach (var header in headers)
{
req.Headers.Add(header.Key, header.Value);
}
}
requestBodyText = executeCallback(req);
using (var resp = req.GetResponse() as HttpWebResponse)
{
if (responseBuilderCallback != null)
{
response = responseBuilderCallback(resp, false);
}
else
{
response = BuildWebResponse(resp);
}
}
}
catch (WebException ex)
{
if (ex.Response == null)
{
throw;
}
using (var resp = ex.Response as HttpWebResponse)
{
if (responseBuilderCallback != null)
{
response = responseBuilderCallback(resp, true);
}
else
{
response = BuildWebResponse(resp);
}
}
}
var endTime = DateTimeOffset.UtcNow;
// Log the request
if (_logger != null)
{
_logger.Log(method, url.OriginalString, headers, requestBodyText, response, startTime, endTime, settings.ExtendedLoggingData);
}
if (response != null && settings.ResponseActions != null && settings.ResponseActions.ContainsKey(response.StatusCode))
{
var action = settings.ResponseActions[response.StatusCode];
if (action != null)
{
action(response);
}
}
return response;
}, settings.Non200SuccessCodes, settings.RetryCount, settings.RetryDelay));
}
public Task Invoke(HttpContext context)
{
var request = context.Request;
//启用读取request
request.EnableBuffering();
if (!AppConfig.EnableIPDirect && request.Host.Host.MatchInetAddress() && !request.Host.Host.IsPrivateIP())
{
context.Response.Redirect("https://www.baidu.com", true);
//context.Response.StatusCode = 404;
return(Task.CompletedTask);
}
var ip = context.Connection.RemoteIpAddress !.ToString();
var path = HttpUtility.UrlDecode(request.Path + request.QueryString, Encoding.UTF8);
var requestUrl = HttpUtility.UrlDecode(request.Scheme + "://" + request.Host + path);
var match = Regex.Match(path ?? "", CommonHelper.BanRegex);
if (match.Length > 0)
{
RedisHelper.IncrBy("interceptCount");
RedisHelper.LPush("intercept", new IpIntercepter()
{
IP = ip,
RequestUrl = requestUrl,
Time = DateTime.Now,
Referer = request.Headers[HeaderNames.Referer],
UserAgent = request.Headers[HeaderNames.UserAgent],
Remark = $"检测到敏感词拦截：{match.Value}",
Address = request.Location(),
HttpVersion = request.Protocol,
Headers = request.Headers.ToJsonString()
});
context.Response.StatusCode = 404;
context.Response.ContentType = "text/html; charset=utf-8";
return(context.Response.WriteAsync("参数不合法！", Encoding.UTF8));
}
if (!context.Session.TryGetValue("session", out _) && !context.Request.IsRobot())
{
context.Session.Set("session", 0);
var referer = context.Request.Headers[HeaderNames.Referer].ToString();
if (!string.IsNullOrEmpty(referer))
{
try
{
new Uri(referer);//判断是不是一个合法的referer
if (!referer.Contains(context.Request.Host.Value) && !referer.Contains(new[] { "baidu.com", "google", "sogou", "so.com", "bing.com", "sm.cn" }))
{
BackgroundJob.Enqueue <IHangfireBackJob>(job => job.UpdateLinkWeight(referer, ip));
}
}
catch
{
context.Response.StatusCode = 405;
context.Response.ContentType = "text/html; charset=utf-8";
return(context.Response.WriteAsync("您的浏览器不支持访问本站！", Encoding.UTF8));
}
}
}
if (!context.Request.IsRobot())
{
if (request.QueryString.HasValue && request.QueryString.Value.Contains("="))
{
var q = request.QueryString.Value.Trim('?');
requestUrl = requestUrl.Replace(q, q.Split('&').Where(s => !s.StartsWith("cid") && !s.StartsWith("uid")).Join("&"));
}
_requestLogger.Log(ip, requestUrl, context.Request.Headers[HeaderNames.UserAgent], context.Session.Id);
}
if (string.IsNullOrEmpty(context.Session.Get <string>(SessionKey.TimeZone)))
{
context.Session.Set(SessionKey.TimeZone, context.Connection.RemoteIpAddress.GetClientTimeZone());
}
if (!context.Request.Cookies.ContainsKey(SessionKey.RawIP))
{
context.Response.Cookies.Append(SessionKey.RawIP, ip.Base64Encrypt(), new CookieOptions()
{
Expires = DateTimeOffset.Now.AddDays(1),
SameSite = SameSiteMode.Lax
});
}
return(_next(context));
}
