Należy zarejestrować treść żądania i odpowiedzi asp.net webapi 2 do bazy danych

Używam Microsoft Asp.net WebApi2 hostowanego przez IIS. Chciałbym po prostu zarejestrować treść żądania (XML lub JSON) i treść odpowiedzi dla każdego posta.

Nie ma nic specjalnego w tym projekcie ani w kontrolerze przetwarzającym post. Nie interesuje mnie używanie struktur rejestrowania, takich jak nLog, elmah, log4net lub wbudowanych funkcji śledzenia internetowego interfejsu API, chyba że jest to konieczne.

Chcę po prostu wiedzieć, gdzie umieścić mój kod logowania i jak uzyskać rzeczywisty kod JSON lub XML z przychodzących i wychodzących żądań i odpowiedzi.

Metoda mojego posta kontrolera:

public HttpResponseMessage Post([FromBody])Employee employee)
{
   if (ModelState.IsValid)
   {
      // insert employee into to the database
   }

}

Polecam użycie DelegatingHandler. Wtedy nie będziesz musiał martwić się o kod logowania w kontrolerach.

public class LogRequestAndResponseHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        if (request.Content != null)
        {
            // log request body
            string requestBody = await request.Content.ReadAsStringAsync();
            Trace.WriteLine(requestBody);
        }
        // let other handlers process the request
        var result = await base.SendAsync(request, cancellationToken);

        if (result.Content != null)
        {
            // once response body is ready, log it
            var responseBody = await result.Content.ReadAsStringAsync();
            Trace.WriteLine(responseBody);
        }

        return result;
    }
}

Po prostu zastąp Trace.WriteLinekodem logowania i zarejestruj program obsługi w WebApiConfignastępujący sposób:

config.MessageHandlers.Add(new LogRequestAndResponseHandler());

Oto pełna dokumentacja firmy Microsoft dotycząca programów obsługi wiadomości .

Istnieje wiele podejść do ogólnej obsługi rejestrowania żądań / odpowiedzi dla każdego wywołania metody WebAPI:

1. ActionFilterAttribute: Można napisać własne ActionFilterAttributei ozdobić kontroler / metody akcji, aby umożliwić logowanie.

   Wada: Musisz udekorować każdy kontroler / metodę (nadal możesz to zrobić na kontrolerze podstawowym, ale nadal nie rozwiązuje to problemów związanych z cięciem krzyżowym.

2. Zastąp BaseControlleri obsłuż rejestrowanie w tym miejscu.

   Wada: Spodziewamy się / zmuszamy kontrolery do dziedziczenia z niestandardowego kontrolera podstawowego.

3. Korzystanie DelegatingHandler.

   Zaleta: tym podejściem nie dotykamy kontrolera / metody. Delegujący program obsługi siedzi w izolacji i wdzięcznie obsługuje rejestrowanie żądań / odpowiedzi.

Aby uzyskać bardziej szczegółowy artykuł, zapoznaj się z tym http://weblogs.asp.net/fredriknormen/log-message-request-and-response-in-asp-net-webapi .

Jedną z dostępnych opcji jest tworzenie filtru akcji i dekorowanie nim WebApiController / ApiMethod.

Filtr atrybutu

public class MyFilterAttribute : System.Web.Http.Filters.ActionFilterAttribute
    {
        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            if (actionContext.Request.Method == HttpMethod.Post)
            {
                var postData = actionContext.ActionArguments;
                //do logging here
            }
        }
    }

Kontroler WebApi

[MyFilterAttribute]
public class ValuesController : ApiController{..}

lub

[MyFilterAttribute]
public void Post([FromBody]string value){..}

Mam nadzieję że to pomoże.

Uzyskanie dostępu do wiadomości z żądaniem jest łatwe. Twoja klasa bazowaApiController zawiera .Requestwłaściwość , która, jak sugeruje nazwa, zawiera żądanie w formie przeanalizowanej. Po prostu sprawdzasz go pod kątem tego, co chcesz zarejestrować, i przekazujesz go do swojego centrum logowania, cokolwiek to jest. Ten kod możesz umieścić na początku swojej akcji, jeśli chcesz to zrobić tylko dla jednej lub kilku osób.

Jeśli musisz to zrobić dla wszystkich akcji (wszystko to znaczy więcej niż garstka, którą można zarządzać), to możesz zrobić .ExecuteAsyncmetodę nadpisania , aby przechwycić każde wywołanie akcji dla twojego kontrolera.

public override Task<HttpResponseMessage> ExecuteAsync(
    HttpControllerContext controllerContext,
    CancellationToken cancellationToken
)
{
    // Do logging here using controllerContext.Request
    return base.ExecuteAsync(controllerContext, cancellationToken);
}

Wydaje się, że to dość stary wątek, ale warto udostępnić inne rozwiązanie.

Możesz dodać tę metodę w swoim pliku global.asax, która będzie uruchamiana po zakończeniu żądania HTTP.

void Application_EndRequest(Object Sender, EventArgs e)
    {
        var request = (Sender as HttpApplication).Request;
        var response = (Sender as HttpApplication).Response;

        if (request.HttpMethod == "POST" || request.HttpMethod == "PUT")
        {


            byte[] bytes = request.BinaryRead(request.TotalBytes);
            string body = Encoding.UTF7.GetString(bytes);
            if (!String.IsNullOrEmpty(body))
            {


                // Do your logic here (Save in DB, Log in IIS etc.)
            }
        }
    }

To naprawdę stary temat, ale spędziłem dużo czasu (przeszukując internet), aby to zrobić, więc po prostu opublikuję tutaj swoje rozwiązanie.

Pojęcie

1. Zastąp ExecuteAsync metody APicontroller do śledzenia żądań przychodzących, w moim rozwiązaniu tworzę Base_ApiController jako rodzica kontrolerów API mojego projektu.
2. Użyj System.Web.Http.Filters.ActionFilterAttribute do śledzenia odpowiedzi wychodzącej kontrolera API
3. *** (Dodatkowe) *** Użyj System.Web.Http.Filters.ExceptionFilterAttribute, aby zarejestrować, gdy wystąpi wyjątek.

1. MyController.cs

    [APIExceptionFilter]  // use 3.
    [APIActionFilter]     // use 2.
    public class Base_APIController : ApiController
    {
        public   bool  IsLogInbound
        {
            get
            { return   ConfigurationManager.AppSettings["LogInboundRequest"] =="Y"? true:false ;     }
        }
        /// <summary>
        /// for logging exception
        /// </summary>
        /// <param name="controllerContext"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public override Task<HttpResponseMessage> ExecuteAsync(
         HttpControllerContext controllerContext,
         CancellationToken cancellationToken
         )
        {
            // Do logging here using controllerContext.Request
            // I don't know why calling the code below make content not null Kanit P.
            var content = controllerContext.Request.Content.ReadAsStringAsync().Result.ToString(); // keep request json content
             // Do your own logging!
            if (IsLogInbound)
            {
                try
                {
                    ErrLog.Insert(ErrLog.type.InboundRequest, controllerContext.Request,
                         controllerContext.Request.RequestUri.AbsoluteUri
                         , content);
                }
                catch (Exception e) { }
            }

            // will not log err when go to wrong controller's action (error here but not go to APIExceptionFilter)
            var t = base.ExecuteAsync(controllerContext, cancellationToken);
            if (!t.Result.IsSuccessStatusCode)
            { 
            }
            return t;

        }

2. APIActionFilter.cs

    public class APIActionFilter : System.Web.Http.Filters.ActionFilterAttribute
    {
        public bool LogOutboundRequest
        {
            get
            { return ConfigurationManager.AppSettings["LogInboundRequest"] == "Y" ? true : false; }
        }

        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            try {

                var returndata = actionExecutedContext.Response.Content.ReadAsStringAsync().Result.ToString(); 
             //keep Json response content
             // Do your own logging!
                if (LogOutboundRequest)
                {
                    ErrLog.Insert(ErrLog.type.OutboundResponse, actionExecutedContext.Response.Headers,
                       actionExecutedContext.ActionContext.ControllerContext.ControllerDescriptor.ControllerName
                      + "/"
                      + actionExecutedContext.ActionContext.ActionDescriptor.ActionName
                      , returndata );
                }
            } catch (Exception e) {

            }
     

        } 
    }
}

3. APIExceptionFilter.cs

    public class APIExceptionFilter : ExceptionFilterAttribute
    {
    public bool IsLogErr
    {
        get
        { return ConfigurationManager.AppSettings["LogExceptionRequest"] == "Y" ? true : false; }
    }


    public override void OnException(HttpActionExecutedContext context)
    {
        try
        { 
            //Do your own logging!
            if (IsLogErr)
            {
                ErrLog.Insert(ErrLog.type.APIFilterException, context.Request,
                    context.ActionContext.ControllerContext.ControllerDescriptor.ControllerName
                    + "/"
                    + context.ActionContext.ActionDescriptor.ActionName
                    , context.Exception.ToString() + context.Exception.StackTrace);
            }
        }catch(Exception e){

        }

        if (context.Exception is NotImplementedException)
        {
            context.Response = new HttpResponseMessage(HttpStatusCode.NotImplemented);
        }
        else {
            context.Response = new HttpResponseMessage(HttpStatusCode.InternalServerError);

        }
    }
}