Custom And Thread Safe Logging .NET Core API

using System;
using System.IO;
using System.Threading.Tasks;

namespace LoggingDemo.Logging
{
	public class Logger
	{
		public async Task Log(string logMessage)
		{
			try
			{
				string dirPath = @"D:\Log";
				string fileName = Path.Combine(@"D:\Log", "Log" + DateTime.Now.ToString("yyyy-MM-dd") + ".txt");

				await WriteToLog(dirPath, fileName, logMessage);
			}
			catch (Exception e)
			{
				Console.WriteLine(e.Message);
			}
		}

		public async Task WriteToLog(string dir, string file, string content)
		{
			using (StreamWriter outputFile = new StreamWriter(Path.Combine(dir, file), true))
			{
				await outputFile.WriteLineAsync(string.Format("Logged on: {1} at: {2}{0}Message: {3} at {4}{0}--------------------{0}",
						  Environment.NewLine, DateTime.Now.ToLongDateString(),
						  DateTime.Now.ToLongTimeString(), content, DateTime.Now.ToString("dddd, dd MMMM yyyy HH:mm:ss.fff")));
			}
		}
	}
}

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "IsLoggerEnabled": "true"
}

using LoggingDemo.Logging;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.OpenApi.Models;

namespace LoggingDemo
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();

            var isEnabled = Configuration.GetSection("IsLoggerEnabled").Value;
            if (isEnabled == "true")
            {
                services.AddSingleton<Logger>();
            }

            services.AddSwaggerGen();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();

            // This middleware serves generated Swagger document as a JSON endpoint
            app.UseSwagger();

            // This middleware serves the Swagger documentation UI
            app.UseSwaggerUI(c =>
            {
                c.SwaggerEndpoint("/swagger/v1/swagger.json", "LoggingDemo API V1");
            });
            app.UseRouting();
            app.UseAuthorization();
            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
    }
}

So here we defined one condition and take the value of that environmental variable from the app setting file and check if the end-user or developer wants some logging mechanism somewhere inside the codebase while developing for testing some scenarios and monitoring the health of the application.

As you see in the configure service method we register the Logger class in Service Container related to Dependency Injection and also enable swagger for testing endpoint,

Step 5

Create one Test Controller and put some code for testing purposes as I mentioned below

using LoggingDemo.Logging;
using Microsoft.AspNetCore.Mvc;

namespace LoggingDemo.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class TestController : ControllerBase
    {
        private readonly Logger logger;
        public TestController(Logger _logger)
        {
            logger = _logger;   
        }

        [HttpGet]
        [Route("login")]
        public string Login()
        {
            _ = logger.Log("login succesfull");
            return "You have logged in successfully";
        }
    }
}

So here you can see we inject the Logger Class inside the Constructor and then use that inside the Login method just for testing.

Step 6

Finally, run the application and hit the endpoint

Step 7

So here inside the Log file you can see the log is maintained in a well-structured format and which is very useful for us in many scenarios

Conclusion

So here we discussed how we implement custom and thread-safe logging and you can also able to use this in the synchronous method and also discussed how to register using Dependency Injection based on environmental variable and use it after injecting it into the API controller.

I hope you understand.

Happy Coding!

If you want to learn and explore dependency injection then visit my following blog

• Dependency Injection And Different Ways To Inject It using .NET Core API