/// <summary>
    /// Slack Logger
    /// </summary>
    public class SlackLogger : ILogger
    {
        readonly ISlackService _slackService;

        public SlackLogger([FromServices] ISlackService slackService)
        {
            _slackService = slackService;
        }


        public async void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
        {
            if (IsEnabled(logLevel))
            {
                var msg = formatter(state, exception);

                 await _slackService.SendMessageAsync(msg);
            }
        }

        public IDisposable BeginScope<TState>(TState state)
        {
            return null;
        }

        public bool IsEnabled(LogLevel logLevel)
        {
            switch (logLevel)
            {
                case LogLevel.Trace:
                    break;
                case LogLevel.Debug:
                    break;
                case LogLevel.Information:
                    break;
                case LogLevel.Warning:
                    break;
                case LogLevel.Error:
                    break;
                case LogLevel.Critical:
                    break;
                case LogLevel.None:
                    break;
                default:
                    break;
            }
            return true;
        }


    }




    /// <summary>
    /// Logger Provider
    /// </summary>
    public class LoggerSlackProvider : ILoggerProvider
    {
        readonly ISlackService _slackService;

        public LoggerSlackProvider(ISlackService slackService)
        {
            _slackService = slackService;
        }

        public ILogger CreateLogger(string categoryName)
        {
            return new SlackLogger(_slackService);
        }

        public void Dispose()
        {
            //throw new NotImplementedException();
        }
    }

    public class Startup
    {
      .....

        public void Configure(IApplicationBuilder app, ILogger<Startup> logger,
            IServiceProvider serviceProvider, ILoggerFactory loggerFactory, ISlackService slackService)
        {
              ......................

            // add Slack Logger
            loggerFactory.AddProvider(new LoggerSlackProvider(slackService));
        }

     }

        public bool IsEnabled(LogLevel logLevel)
        {
              return true;
        }

    
using MyGlobal.Extensions
{
public static class CommonExtensions
{
        public async static void LogSlack(this ILogger logger, string message, ISlackService slackService, LogLevel logLevel = LogLevel.Information)
        {

            if (slackService != null)
            {
                var msg = $"{DateTime.Now} ( {Enum.GetName(typeof(LogLevel), logLevel)} ): {message}";

                try
                {
                    var result = await slackService.SendMessageAsync(msg);
                }
                catch (Exception ex)
                {
                    ...
                }
            }

        }

}
}

using MyGlobal.Extensions;

        readonly ILogger<DevController> _logger;

        public DevController(ILogger<DevController> logger)
        {
            _logger = logger;
        }
        [HttpPost]
        public async Task<PipeResponse> GetImages(string token, string alias, [FromServices] ISlackService slackService)
        {
            _logger.LogSlack("Test msg", slackService);
            _logger.LogSlack("Test msg Critical", slackService, LogLevel.Critical);
            _logger.LogSlack("Test msg Error", slackService, LogLevel.Error);
            _logger.LogSlack("Test msg Warning", slackService, LogLevel.Warning);
           ...
           _logger.LogWarning($"warning");
            return resp;
        }