public override void Log(ExceptionLoggerContext context)
        {
            if (context != null && context.Exception != null && context.Request != null)
            {
                string excToString = context.Exception.ToString();

                var entityValidationExc = context.Exception as System.Data.Entity.Validation.DbEntityValidationException;
                if (entityValidationExc != null)
                    excToString += Environment.NewLine
                                + string.Join(Environment.NewLine, entityValidationExc.EntityValidationErrors.SelectMany(p => p.ValidationErrors.Select(q => q.PropertyName + ": " + q.ErrorMessage)));

                var usedController = ((System.Web.Http.ApiController)context.ExceptionContext.ControllerContext.Controller);

                //similar to Global.asax/CustomLogRequest
                //todo: missing user and IP, catch Exceptions and null reference
                Trace.TraceError("CustomExceptionLogger"
                                 + Environment.NewLine
                                 + "HTTP {0} {1}"
                                 + Environment.NewLine
                                 + "Form Keys: {2}"
                                 + Environment.NewLine,
                                 //+ "User: {3}, IP: {4}",
                                 context.Request.Method.Method, context.Request.RequestUri,
                                 string.Join(Environment.NewLine,
                                            usedController.ActionContext.ActionArguments.Select(p => p.Key + ": " + JsonConvert.SerializeObject(p.Value))));
                //username, ip);
            }
        }

 public override void Log(ExceptionLoggerContext context)
 {
     if (context != null)
     {
         Trace.TraceError(context.ExceptionContext.Exception.ToString());
     }
 }

        public Task LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken)
        {
            var logger = context.Request.GetAutofacScope().Resolve<ILogger>();
            logger.ErrorFormat("Unhandled exception: {0}", context.Exception);

            return Task.FromResult<object>(null);
        }

 public override void Log(ExceptionLoggerContext context)
 {
     #if DEBUG
     Debug.WriteLine("Logging");
     #endif
     logger.Log(LogLevel.Trace, context.Exception);
 }

        public override void Log(ExceptionLoggerContext context) {
            var contextData = new ContextData();
            contextData.MarkAsUnhandledError();
            contextData.SetSubmissionMethod("ExceptionLogger");
            contextData.Add("HttpActionContext", context.ExceptionContext.ActionContext);

            context.Exception.ToExceptionless(contextData).Submit();
        }

 public override void Log(ExceptionLoggerContext context)
 {
     var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "App_Data");
     path = Path.Combine(path, "UserAdminException.txt");
     Directory.CreateDirectory(path);
     var msg = DateTime.Now.ToString() + Environment.NewLine + context.Exception.ToString() + Environment.NewLine + Environment.NewLine;
     File.AppendAllText(path, msg);
 }

        public Task LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken)
        {
            string requestDescription = context.Request.GetDescription();

            logger.WriteCritical($"Exception while processing {requestDescription}.", context.Exception);

            return Task.FromResult(true);
        }

        public void Log(Exception ex, HttpRequestMessage request, string catchBlockName)
        {
            var catchBlock = new ExceptionContextCatchBlock(catchBlockName, true, false);
            var exceptionContext = new ExceptionContext(ex, catchBlock, request);
            var exceptionLoggerContext = new ExceptionLoggerContext(exceptionContext);

            Log(exceptionLoggerContext);
        }

 public override void Log(ExceptionLoggerContext context)
 {
     using (var log = Logger.GetLogger(this))
      {
     string errorMessage = $"Unhandled exception processing {context.Request.Method} for {context.Request.RequestUri}: {context.Exception}";
     log.Error(errorMessage);
      }
 }

        public async Task LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken)
        {
            Logger.ErrorException("Unhandled exception", context.Exception);

            var env = context.Request.GetOwinEnvironment();
            var events = env.ResolveDependency<IEventService>();
            await events.RaiseUnhandledExceptionEventAsync(context.Exception);
        }

 public override void Log(ExceptionLoggerContext context) {
     _logger.Error()
         .Exception(context.Exception)
         .SetActionContext(context.ExceptionContext.ActionContext)
         .MarkUnhandled("ExceptionLogger")
         .Message("Unhandled: {0}", context.Exception.Message)
         .Write();
 }

 public override void Log(ExceptionLoggerContext context)
 {
     if (context?.Exception != null)
     {
         _AiClient.TrackException(context.Exception);
     }
     base.Log(context);
 }

 private bool ShouldLogAsError(ExceptionLoggerContext context)
 {
     return (!(context.Exception is MdmFaultException) &&
             !(context.Exception is NotFoundException) &&
             !(context.Exception is ValidationException) &&
             !(context.Exception is NotImplementedException) &&
             !(context.Exception is VersionConflictException)
             );
 }

        public override void Log(ExceptionLoggerContext context)
        {
            var shouldBeWarning = Extension.IsType(context.Exception, new List<Type> { typeof(ValidationException), typeof(BaseLogicException<>) });

            if (shouldBeWarning)
                Logger.Warn(context.Exception.GetType().Name, context.Exception);
            else
                Logger.Error("An unhandled exception has occured", context.Exception);
        }

        public override void Log(ExceptionLoggerContext context)
        {
            var logger = context.Request.GetDependencyScope().GetService(typeof(ILogger)) as ILogger;

            if (logger != null && context.Exception != null)
            {
                logger.Log(context.Exception.Message);
            }
        }

        public override void Log(ExceptionLoggerContext context)
        {
            //either use tracing for logging
            //Trace.TraceError(context.ExceptionContext.Exception.ToString());
            //or use Semantic Logging Application Block(SLAB)
            //FoodnetworkEventSource.Log.Error("unexpectedError","Error",context.ExceptionContext.Exception.ToString());

            FoodnetworkEventSource.Log.ErrorLog("test");
        }

        public override void Log(ExceptionLoggerContext context)
        {
            using (var log = new LoggerConfiguration().ReadFrom.AppSettings().CreateLogger())
            {
                log.Error(context.Exception, "CustomExceptionLogger: An exception occurred in an API controller; see the log entry below for the request");
            }

            base.Log(context);
        }

        public override void Log(ExceptionLoggerContext context)
        {
            // Não loga se for exceção de regra de negócio
            if (context.Exception is BusinessException)
                return;

            // Loga apenas quando for uma Exception (Erro no sistema)
            Trace.TraceError(context.ExceptionContext.Exception.ToString());
        }

 public override void Log(ExceptionLoggerContext context)
 {
     if (context != null && context.Exception != null)
     {//or reuse instance (recommended!). see note above 
         var ai = new TelemetryClient();
         ai.TrackException(context.Exception);
     }
     base.Log(context);
 }

        public Task LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken)
        {
            Logger.ErrorException("Unhandled exception", context.Exception);

            var env = context.Request.GetOwinEnvironment();
            var events = env.ResolveDependency<IEventService>();
            events.RaiseUnhandledExceptionEvent(context.Exception);

            return Task.FromResult<object>(null);
        }