La journalisation HTTP brut de requête/réponse en ASP.NET MVC & IIS7

La suite de la méthode d'extension sur HttpRequest va créer une chaîne qui peut être collé dans fiddler et relus.

namespace System.Web
{
using System.IO;
///<summary>
///Extension methods for HTTP Request.
///<remarks>
///See the HTTP 1.1 specification http://www.w3.org/Protocols/rfc2616/rfc2616.html
///for details of implementation decisions.
///</remarks>
///</summary>
public static class HttpRequestExtensions
{
///<summary>
///Dump the raw http request to a string. 
///</summary>
///<param name="request">The <see cref="HttpRequest"/> that should be dumped.       </param>
///<returns>The raw HTTP request.</returns>
public static string ToRaw(this HttpRequest request)
{
StringWriter writer = new StringWriter();
WriteStartLine(request, writer);
WriteHeaders(request, writer);
WriteBody(request, writer);
return writer.ToString();
}
private static void WriteStartLine(HttpRequest request, StringWriter writer)
{
const string SPACE = " ";
writer.Write(request.HttpMethod);
writer.Write(SPACE + request.Url);
writer.WriteLine(SPACE + request.ServerVariables["SERVER_PROTOCOL"]);
}
private static void WriteHeaders(HttpRequest request, StringWriter writer)
{
foreach (string key in request.Headers.AllKeys)
{
writer.WriteLine(string.Format("{0}: {1}", key, request.Headers[key]));
}
writer.WriteLine();
}
private static void WriteBody(HttpRequest request, StringWriter writer)
{
StreamReader reader = new StreamReader(request.InputStream);
try
{
string body = reader.ReadToEnd();
writer.WriteLine(body);
}
finally
{
reader.BaseStream.Position = 0;
}
}
}
}

Bien, je suis en train de travailler sur un projet et n'a, peut-être pas trop profonde, d'un journal à l'aide de la demande params:

Prendre un coup d'oeil:

public class LogAttribute : ActionFilterAttribute
{
private void Log(string stageName, RouteData routeData, HttpContextBase httpContext)
{
//Use the request and route data objects to grab your data
string userIP = httpContext.Request.UserHostAddress;
string userName = httpContext.User.Identity.Name;
string reqType = httpContext.Request.RequestType;
string reqData = GetRequestData(httpContext);
string controller = routeData["controller"];
string action = routeData["action"];
//TODO:Save data somewhere
}
//Aux method to grab request data
private string GetRequestData(HttpContextBase context)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < context.Request.QueryString.Count; i++)
{
sb.AppendFormat("Key={0}, Value={1}<br/>", context.Request.QueryString.Keys[i], context.Request.QueryString[i]);
}
for (int i = 0; i < context.Request.Form.Count; i++)
{
sb.AppendFormat("Key={0}, Value={1}<br/>", context.Request.Form.Keys[i], context.Request.Form[i]);
}
return sb.ToString();
}

Vous pouvez décorer vos contrôleurs de classe pour le journal entièrement:

[Log]
public class TermoController : Controller {...}

journal ou juste certaines méthodes d'action

[Log]
public ActionResult LoggedAction(){...}

Je suis allé avec McKAMEY de l'approche. Voici un module que j'ai écrit qui vous permettra de commencer et j'espère vous faire économiser du temps. Vous aurez besoin de brancher l'Enregistreur à l'évidence avec quelque chose qui fonctionne pour vous:

public class CaptureTrafficModule : IHttpModule
{
public void Init(HttpApplication context)
{
context.BeginRequest += new EventHandler(context_BeginRequest);
context.EndRequest += new EventHandler(context_EndRequest);
}
void context_BeginRequest(object sender, EventArgs e)
{
HttpApplication app = sender as HttpApplication;
OutputFilterStream filter = new OutputFilterStream(app.Response.Filter);
app.Response.Filter = filter;
StringBuilder request = new StringBuilder();
request.Append(app.Request.HttpMethod + " " + app.Request.Url);
request.Append("\n");
foreach (string key in app.Request.Headers.Keys)
{
request.Append(key);
request.Append(": ");
request.Append(app.Request.Headers[key]);
request.Append("\n");
}
request.Append("\n");
byte[] bytes = app.Request.BinaryRead(app.Request.ContentLength);
if (bytes.Count() > 0)
{
request.Append(Encoding.ASCII.GetString(bytes));
}
app.Request.InputStream.Position = 0;
Logger.Debug(request.ToString());
}
void context_EndRequest(object sender, EventArgs e)
{
HttpApplication app = sender as HttpApplication;
Logger.Debug(((OutputFilterStream)app.Response.Filter).ReadStream());
}
private ILogger _logger;
public ILogger Logger
{
get
{
if (_logger == null)
_logger = new Log4NetLogger();
return _logger;
}
}
public void Dispose()
{
//Does nothing
}
}

utiliser un IHttpModule:

    namespace Intercepts
{
class Interceptor : IHttpModule
{
private readonly InterceptorEngine engine = new InterceptorEngine();
#region IHttpModule Members
void IHttpModule.Dispose()
{
}
void IHttpModule.Init(HttpApplication application)
{
application.EndRequest += new EventHandler(engine.Application_EndRequest);
}
#endregion
}
}
class InterceptorEngine
{       
internal void Application_EndRequest(object sender, EventArgs e)
{
HttpApplication application = (HttpApplication)sender;
HttpResponse response = application.Context.Response;
ProcessResponse(response.OutputStream);
}
private void ProcessResponse(Stream stream)
{
Log("Hello");
StreamReader sr = new StreamReader(stream);
string content = sr.ReadToEnd();
Log(content);
}
private void Log(string line)
{
Debugger.Log(0, null, String.Format("{0}\n", line));
}
}

Vous pouvez accomplir ceci dans une DelegatingHandler sans l'aide de la OutputFilter mentionné dans d'autres réponses .NET 4.5 utilisation de la Stream.CopyToAsync() fonction.

Je ne suis pas sûr que sur les détails, mais elle ne déclenche pas toutes les mauvaises choses qui se passera si vous essayez de lire directement le flux de réponse.

Exemple:

public class LoggingHandler : DelegatingHandler
{
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
DoLoggingWithRequest(request);
var response = await base.SendAsync(request, cancellationToken);
await DoLoggingWithResponse(response);
return response;
}
private async Task DologgingWithResponse(HttpResponseMessage response) {
var stream = new MemoryStream();
await response.Content.CopyToAsync(stream).ConfigureAwait(false);     
DoLoggingWithResponseContent(Encoding.UTF8.GetString(stream.ToArray()));
//The rest of this call, the implementation of the above method, 
//and DoLoggingWithRequest is left as an exercise for the reader.
}
}

Je suis d'accord avec les autres, utiliser un IHttpModule. Jetez un oeil à la réponse à cette question, qui fait à peu près la même chose que ce que vous demandez. Il enregistre la demande et de la réponse, mais sans les en-têtes.

Comment tracer ScriptService WebService demandes?

D'accord avec FigmentEngine, IHttpModule semble être la voie à suivre.

Regarder dans httpworkerrequest, readentitybody et GetPreloadedEntityBody.

Pour obtenir le httpworkerrequest vous avez besoin pour ce faire:

(HttpWorkerRequest)inApp.Context.GetType().GetProperty("WorkerRequest", bindingFlags).GetValue(inApp.Context, null);

où inApp est l'objet httpapplication.