RESTful Day #6: Request Logging And Exception Handing/Logging In Web APIs Using Action Filters, Exception Filters and NLog

Step 2. Modify NLogger Class.

Our NLogger class is capable of logging all info and events, I have made some changes in the private method Log() to handle the exceptions.

#region Private member methods.

/// <summary>
/// Logs info/Error to Log file
/// </summary>
/// <param name="record"></param>
private void Log(TraceRecord record)
{
    var message = new StringBuilder();

    if (!string.IsNullOrWhiteSpace(record.Message))
        message.Append("").Append(record.Message + Environment.NewLine);

    if (record.Request != null)
    {
        if (record.Request.Method != null)
            message.Append("Method: " + record.Request.Method + Environment.NewLine);

        if (record.Request.RequestUri != null)
            message.Append("").Append("URL: " + record.Request.RequestUri + Environment.NewLine);

        if (record.Request.Headers != null && record.Request.Headers.Contains("Token") && record.Request.Headers.GetValues("Token") != null && record.Request.Headers.GetValues("Token").FirstOrDefault() != null)
            message.Append("").Append("Token: " + record.Request.Headers.GetValues("Token").FirstOrDefault() + Environment.NewLine);
    }

    if (!string.IsNullOrWhiteSpace(record.Category))
        message.Append("").Append(record.Category);

    if (!string.IsNullOrWhiteSpace(record.Operator))
        message.Append(" ").Append(record.Operator).Append(" ").Append(record.Operation);

    if (record.Exception != null && !string.IsNullOrWhiteSpace(record.Exception.GetBaseException().Message))
    {
        var exceptionType = record.Exception.GetType();
        message.Append(Environment.NewLine);
        message.Append("").Append("Error: " + record.Exception.GetBaseException().Message + Environment.NewLine);
    }

    Logger[record.Level](Convert.ToString(message) + Environment.NewLine);
}

#endregion

Step 3. Modify Controller for Exceptions.

Our application is now ready to run, but there is no exception in our code, so I added a throw exception code in ProductController, just the Get(int id) method so that it can throw exception for testing our exception logging mechanism, It will throw an exception if the product is not there in the database with the provided id.

// GET api/product/5
[GET("productid/{id?}")]
[GET("particularproduct/{id?}")]
[GET("myproduct/{id:range(1, 3)}")]
public HttpResponseMessage Get(int id)
{
    var product = _productServices.GetProductById(id);
    if (product != null)
        return Request.CreateResponse(HttpStatusCode.OK, product);

    throw new Exception("No product found for this id");
    //return Request.CreateErrorResponse(HttpStatusCode.NotFound, "No product found for this id");
}

Step 4. Run the application.

Run the application and click on Product/all API.

Add the parameter id value to 1 and the header Token with its current value, and click on the send button to get the result.

Now we can see that the Status is 200/OK, and we also get a product with the provided ID in the response body. Let’s see the API log now.

The log has captured the call of Product API, now provide a new product ID as a parameter, which is not there in the database, I am using 12345 as the product ID and the result is.

We can see there is a 500/Internal Server Error now in response status, let's check the API Log.

Well, now the log has captured both the event and error of the same call on the server, you can see call log details and the error with the provided error message in the log.

Custom Exception logging

In the above section, we have implemented exception logging, but there is a default system response and status ( i. e. 500/Internal Server Error), It will be always good to have your own custom response and exceptions for your API. That will make it easier for the client to consume and understand the API responses.

Step 1. Add Custom Exception Classes.

Add the “Error Helper” folder to the application to maintain our custom exception classes separately and add the “IApiExceptions” interface to the newly created “ErrorHelper” folder.

Add the following code in the IApiExceptions interface, this will serve as a template for all exception classes, I have added four common properties for our custom classes to maintain Error Code, ErrorDescription, HttpStatus (Contains the values of status codes defined for HTTP) and ReasonPhrase.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;

namespace WebApi.ErrorHelper
{
    /// <summary>
    /// IApiExceptions Interface
    /// </summary>
    public interface IApiExceptions
    {
        /// <summary>
        /// ErrorCode
        /// </summary>
        int ErrorCode { get; set; }
        /// <summary>
        /// ErrorDescription
        /// </summary>
        string ErrorDescription { get; set; }
        /// <summary>
        /// HttpStatus
        /// </summary>
        HttpStatusCode HttpStatus { get; set; }
        /// <summary>
        /// ReasonPhrase
        /// </summary>
        string ReasonPhrase { get; set; }
    }
}

Here, I divided our exceptions into the following three categories.

1. API Exceptions: for API level exceptions.
2. Business Exceptions: for exceptions at the business logic level.
3. Data Exceptions: Data-related exceptions.

To implement this create three new classes ApiException.cs, ApiDataException.cs, and ApiBusinessException classes to the same folder which implements the IApiExceptions interface with the following code to the classes.

#region Using namespaces.
using System;
using System.Net;
using System.Runtime.Serialization;
#endregion


namespace WebApi.ErrorHelper
{
    /// <summary>
    /// Api Exception
    /// </summary>
    [Serializable]
    [DataContract]
    public class ApiException : Exception, IApiExceptions
    {
        #region Public Serializable properties.
        [DataMember]
        public int ErrorCode { get; set; }
        [DataMember]
        public string ErrorDescription { get; set; }
        [DataMember]
        public HttpStatusCode HttpStatus { get; set; }

        string reasonPhrase = "ApiException";

        [DataMember]
        public string ReasonPhrase
        {
            get { return this.reasonPhrase; }

            set { this.reasonPhrase = value; }
        }
        #endregion
    }
}

I have initialized the ReasonPhrase property with different default values in these classes to differentiate the implementation, you can implement your custom classes as per your application needs.

The directives applied on class as Serializable and DataContract to make sure that the class defines or implements a data contract serializable and can be serialized by a serializer.

Note. Add reference of “System.Runtime.Serialization.dll” dll if you facing any assembly issues.

In the same way, add the “ApiBusinessException” and “ApiDataException” classes into the same folder with the following code.

#region Using namespaces.
using System;
using System.Net;
using System.Runtime.Serialization;
#endregion

namespace WebApi.ErrorHelper
{
    /// <summary>
    /// Api Business Exception
    /// </summary>
    [Serializable]
    [DataContract]
    public class ApiBusinessException : Exception, IApiExceptions
    {
        #region Public Serializable properties.
        [DataMember]
        public int ErrorCode { get; set; }
        [DataMember]
        public string ErrorDescription { get; set; }
        [DataMember]
        public HttpStatusCode HttpStatus { get; set; }

        string reasonPhrase = "ApiBusinessException";

        [DataMember]
        public string ReasonPhrase
        {
            get { return this.reasonPhrase; }

            set { this.reasonPhrase = value; }
        }
        #endregion

        #region Public Constructor.
        /// <summary>
        /// Public constructor for Api Business Exception
        /// </summary>
        /// <param name="errorCode"></param>
        /// <param name="errorDescription"></param>
        /// <param name="httpStatus"></param>
        public ApiBusinessException(int errorCode, string errorDescription, HttpStatusCode httpStatus)
        {
            ErrorCode = errorCode;
            ErrorDescription = errorDescription;
            HttpStatus = httpStatus;
        }
        #endregion

    }
}

#region Using namespaces.
using System;
using System.Net;
using System.Runtime.Serialization;
#endregion

namespace WebApi.ErrorHelper
{
    /// <summary>
    /// Api Data Exception
    /// </summary>
    [Serializable]
    [DataContract]
    public class ApiDataException : Exception, IApiExceptions
    {
        #region Public Serializable properties.
        [DataMember]
        public int ErrorCode { get; set; }
        [DataMember]
        public string ErrorDescription { get; set; }
        [DataMember]
        public HttpStatusCode HttpStatus { get; set; }

        string reasonPhrase = "ApiDataException";

        [DataMember]
        public string ReasonPhrase
        {
            get { return this.reasonPhrase; }

            set { this.reasonPhrase = value; }
        }
        #endregion

        #region Public Constructor.
        /// <summary>
        /// Public constructor for Api Data Exception
        /// </summary>
        /// <param name="errorCode"></param>
        /// <param name="errorDescription"></param>
        /// <param name="httpStatus"></param>
        public ApiDataException(int errorCode, string errorDescription, HttpStatusCode httpStatus)
        {
            ErrorCode = errorCode;
            ErrorDescription = errorDescription;
            HttpStatus = httpStatus;
        }
        #endregion
    }
}

JSON Serializers

There are some objects that need to be serialized in JSON, to log and transfer through the modules, for this I have added some extension methods to the Object class.

For that add a “System.Web.Extensions.dll” reference to the project and add the “JSONHelper” class to the Helpers folder with the following cod.

#region Using namespaces.
using System.Web.Script.Serialization;
using System.Data;
using System.Collections.Generic;
using System;
#endregion

namespace WebApi.Helpers
{
    public static class JSONHelper
    {
        #region Public extension methods.
        /// <summary>
        /// Extened method of object class, Converts an object to a json string.
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static string ToJSON(this object obj)
        {
            var serializer = new JavaScriptSerializer();
            try
            {
                return serializer.Serialize(obj);
            }
            catch(Exception ex)
            {
                return "";
            }
        }
        #endregion
    }
}

In the above code “ToJSON()” method is an extension of the base Object class, which serializes the object to a JSON string. The method using the “JavaScriptSerializer” class which exist in “System.Web.Script.Serialization”.

Modify NLogger Class

For exception handling, I have modified the Log() method of NLogger, which will now handle different API exceptions.

/// <summary>
/// Logs info/Error to Log file
/// </summary>
/// <param name="record"></param>
private void Log(TraceRecord record)
{
    var message = new StringBuilder();

    if (!string.IsNullOrWhiteSpace(record.Message))
        message.Append("").Append(record.Message + Environment.NewLine);

    if (record.Request != null)
    {
        if (record.Request.Method != null)
            message.Append("Method: " + record.Request.Method + Environment.NewLine);

        if (record.Request.RequestUri != null)
            message.Append("").Append("URL: " + record.Request.RequestUri + Environment.NewLine);

        if (record.Request.Headers != null && record.Request.Headers.Contains("Token") && record.Request.Headers.GetValues("Token") != null && record.Request.Headers.GetValues("Token").FirstOrDefault() != null)
            message.Append("").Append("Token: " + record.Request.Headers.GetValues("Token").FirstOrDefault() + Environment.NewLine);
    }

    if (!string.IsNullOrWhiteSpace(record.Category))
        message.Append("").Append(record.Category);

    if (!string.IsNullOrWhiteSpace(record.Operator))
        message.Append(" ").Append(record.Operator).Append(" ").Append(record.Operation);

    if (record.Exception != null && !string.IsNullOrWhiteSpace(record.Exception.GetBaseException().Message))
    {
        var exceptionType = record.Exception.GetType();
        message.Append(Environment.NewLine);
        if (exceptionType == typeof(ApiException))
        {
            var exception = record.Exception as ApiException;
            if (exception != null)
            {
                message.Append("").Append("Error: " + exception.ErrorDescription + Environment.NewLine);
                message.Append("").Append("Error Code: " + exception.ErrorCode + Environment.NewLine);
            }
        }
        else if (exceptionType == typeof(ApiBusinessException))
        {
            var exception = record.Exception as ApiBusinessException;
            if (exception != null)
            {
                message.Append("").Append("Error: " + exception.ErrorDescription + Environment.NewLine);
                message.Append("").Append("Error Code: " + exception.ErrorCode + Environment.NewLine);
            }
        }
        else if (exceptionType == typeof(ApiDataException))
        {
            var exception = record.Exception as ApiDataException;
            if (exception != null)
            {
                message.Append("").Append("Error: " + exception.ErrorDescription + Environment.NewLine);
                message.Append("").Append("Error Code: " + exception.ErrorCode + Environment.NewLine);
            }
        }
        else
            message.Append("").Append("Error: " + record.Exception.GetBaseException().Message + Environment.NewLine);
    }

    Logger[record.Level](Convert.ToString(message) + Environment.NewLine);
}

The code above checks the exception object of TraceRecord and updates the logger as per the exception type.

Modify GlobalExceptionAttribute

As we have created GlobalExceptionAttribute to handle al the exceptions and create a response in case of any exceptions. Now I have added some new code to this in order to enable the GlobalExceptionAttribute class to handle custom exceptions. I am adding only the modified method here for your reference.

public override void OnException(HttpActionExecutedContext context)
{
    GlobalConfiguration.Configuration.Services.Replace(typeof(ITraceWriter), new NLogger());
    var trace = GlobalConfiguration.Configuration.Services.GetTraceWriter();
    trace.Error(context.Request, "Controller : " + context.ActionContext.ControllerContext.ControllerDescriptor.ControllerType.FullName + Environment.NewLine + "Action : " + context.ActionContext.ActionDescriptor.ActionName, context.Exception);

    var exceptionType = context.Exception.GetType();

    if (exceptionType == typeof(ValidationException))
    {
        var resp = new HttpResponseMessage(HttpStatusCode.BadRequest) { Content = new StringContent(context.Exception.Message), ReasonPhrase = "ValidationException", };
        throw new HttpResponseException(resp);
    }
    else if (exceptionType == typeof(UnauthorizedAccessException))
    {
        throw new HttpResponseException(context.Request.CreateResponse(HttpStatusCode.Unauthorized, new ServiceStatus() { StatusCode = (int)HttpStatusCode.Unauthorized, StatusMessage = "UnAuthorized", ReasonPhrase = "UnAuthorized Access" }));
    }
    else if (exceptionType == typeof(ApiException))
    {
        var webapiException = context.Exception as ApiException;
        if (webapiException != null)
            throw new HttpResponseException(context.Request.CreateResponse(webapiException.HttpStatus, new ServiceStatus() { StatusCode = webapiException.ErrorCode, StatusMessage = webapiException.ErrorDescription, ReasonPhrase = webapiException.ReasonPhrase }));
    }
    else if (exceptionType == typeof(ApiBusinessException))
    {
        var businessException = context.Exception as ApiBusinessException;
        if (businessException != null)
            throw new HttpResponseException(context.Request.CreateResponse(businessException.HttpStatus, new ServiceStatus() { StatusCode = businessException.ErrorCode, StatusMessage = businessException.ErrorDescription, ReasonPhrase = businessException.ReasonPhrase }));
    }
    else if (exceptionType == typeof(ApiDataException))
    {
        var dataException = context.Exception as ApiDataException;
        if (dataException != null)
            throw new HttpResponseException(context.Request.CreateResponse(dataException.HttpStatus, new ServiceStatus() { StatusCode = dataException.ErrorCode, StatusMessage = dataException.ErrorDescription, ReasonPhrase = dataException.ReasonPhrase }));
    }
    else
    {
        throw new HttpResponseException(context.Request.CreateResponse(HttpStatusCode.InternalServerError));
    }
}

In the above code, I have modified the overridden method OnExeption() and created a new HTTP response exception based on the different exception types.

Modify Product Controller

Now modify the Product controller to throw our custom exception form, please look into the Get method I have modified to throw the APIDataException in case if data is not found and APIException in any other kind of error.

// GET api/product/5
[GET("productid/{id?}")]
[GET("particularproduct/{id?}")]
[GET("myproduct/{id:range(1, 3)}")]
public HttpResponseMessage Get(int id)
{
    if (id != null)
    {
        var product = _productServices.GetProductById(id);
        if (product != null)
            return Request.CreateResponse(HttpStatusCode.OK, product);

        throw new ApiDataException(1001, "No product found for this id.", HttpStatusCode.NotFound);
    }
    throw new ApiException() { ErrorCode = (int)HttpStatusCode.BadRequest, ErrorDescription = "Bad Request..." };
}

Run the application

Run the application and click on Product/all API.

Add the parameter id value to 1 and the header Token with its current value, click on the send button to get the result,

Now we can see that the Status is 200/OK, and we also get a product with the provided ID in the response body. Let's see the API log now.

The log has captured the call of Product API, now provide a new product id as a parameter, which is not there in the database, I am using 12345 as the product ID and the result is.

We can see now there is a custom error status code “1001” and the message “No product found for this ID.” The generic status code “500/Internal Server Error” is now replaced with our supplied code “404/ Not Found”, which is more meaningful for the client or consumer.

Let's see the APILog now.

Well, now the log has captured both the event and error of the same call on the server, you can see call log details and the error with the provided error message in the log with our custom error code, I have only captured the error description and error code, but you can add more details in the log as per your application needs.

Update the controller for new Exception Handling

The following is the code for controllers with the implementation of custom exception handling and logging.

Product Controller

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using AttributeRouting;
using AttributeRouting.Web.Http;
using BusinessEntities;
using BusinessServices;
using WebApi.ActionFilters;
using WebApi.Filters;
using WebApi.ErrorHelper;

namespace WebApi.Controllers
{
    [AuthorizationRequired]
    [RoutePrefix("v1/Products/Product")]
    public class ProductController : ApiController
    {
        #region Private variable.

        private readonly IProductServices _productServices;

        #endregion

        #region Public Constructor

        /// <summary>
        /// Public constructor to initialize product service instance
        /// </summary>
        public ProductController(IProductServices productServices)
        {
            _productServices = productServices;
        }

        #endregion

        // GET api/product
        [GET("allproducts")]
        [GET("all")]
        public HttpResponseMessage Get()
        {
            var products = _productServices.GetAllProducts();
            var productEntities = products as List<ProductEntity> ?? products.ToList();
            if (productEntities.Any())
                return Request.CreateResponse(HttpStatusCode.OK, productEntities);
            throw new ApiDataException(1000, "Products not found", HttpStatusCode.NotFound);
        }

        // GET api/product/5
        [GET("productid/{id?}")]
        [GET("particularproduct/{id?}")]
        [GET("myproduct/{id:range(1, 3)}")]
        public HttpResponseMessage Get(int id)
        {
            if (id != null)
            {
                var product = _productServices.GetProductById(id);
                if (product != null)
                    return Request.CreateResponse(HttpStatusCode.OK, product);

                throw new ApiDataException(1001, "No product found for this id.", HttpStatusCode.NotFound);
            }
            throw new ApiException() { ErrorCode = (int)HttpStatusCode.BadRequest, ErrorDescription = "Bad Request..." };
        }

        // POST api/product
        [POST("Create")]
        [POST("Register")]
        public int Post([FromBody] ProductEntity productEntity)
        {
            return _productServices.CreateProduct(productEntity);
        }

        // PUT api/product/5
        [PUT("Update/productid/{id}")]
        [PUT("Modify/productid/{id}")]
        public bool Put(int id, [FromBody] ProductEntity productEntity)
        {
            if (id > 0)
            {
                return _productServices.UpdateProduct(id, productEntity);
            }
            return false;
        }

        // DELETE api/product/5
        [DELETE("remove/productid/{id}")]
        [DELETE("clear/productid/{id}")]
        [PUT("delete/productid/{id}")]
        public bool Delete(int id)
        {
            if (id != null && id > 0)
            {
                var isSuccess = _productServices.DeleteProduct(id);
                if (isSuccess)
                {
                    return isSuccess;
                }
                throw new ApiDataException(1002, "Product is already deleted or not exist in system.", HttpStatusCode.NoContent);
            }
            throw new ApiException() { ErrorCode = (int) HttpStatusCode.BadRequest, ErrorDescription = "Bad Request..." };
        }
    }
}

Now you can see, that our application is so rich and scalable that none of the exceptions or transactions can escape logging. Once setup is in place, now you don’t have to worry about writing code each time for logging or requests and exceptions, but you can relax and focus on business logic only.

Image credit: https://pixabay.com/en/kermit-frog-meadow-daisy-concerns-383370/

Conclusion

In this article, we learned how to perform request logging and exception logging in WebPI. There could be numerous ways in which you can perform these operations but I tried to present this in as simple a way as possible. My approach was to take our enterprise level to the next level of development, where developers should not always be worried about exception handling and logging. Our solution provides a generic approach to centralizing the operations in one place; all the requests and exceptions are automatically taken care of. In my new articles, I’ll try to enhance the application by explaining unit testing in WebAPI and OData in WebAPI. You can download the complete source code of this article with packages from GitHub. Happy coding.

Read more

• C# and ASP.NET Questions (All in one)
• MVC Interview Questions
• C# and ASP.NET Interview Questions and Answers
• Web Services and Windows Services Interview Questions

For more technical articles you can reach out to CodeTeddy

My other series of articles.

• Learning MVC
• Learning OOP concepts with C#