private static void DisplayError(string error, NLog.Logger logger = null)
 {
     if (null != logger)
     {
         logger.Error(error);
     }
     else
     {
         Console.Error.WriteLine(error);
     }
 }

        /// <summary>
        /// This expects a web context; without it, the method will exit early.
        /// </summary>
        /// <param name="logEvent"></param>
        /// <returns></returns>
        public static string GetExceptionDetails(NLog.LogEventInfo logEvent)
        {
            if (HttpContext.Current == null
                || HttpContext.Current.Request == null
                || HttpContext.Current.Server == null) { return ""; }

            var serverVariables = HttpContext.Current.Request.ServerVariables;
            var lastError = HttpContext.Current.Server.GetLastError();

            string errorMessage = (lastError == null) ? logEvent.FormattedMessage : lastError.InnerException.ToString();

            var errorDetails = new StringBuilder();

            errorDetails.AppendFormat("{0}<br /><br />", errorMessage);
            // This helps give meaningful data in the case of "File does not exist" errors
            errorDetails.AppendFormat("File Path: {0}<br /><br />", HttpContext.Current.Request.FilePath);

            // Stack trace
            if (logEvent.StackTrace != null)
                errorDetails.AppendFormat("<i>Stack Trace:</i><br />{0}<br /><br />", logEvent.StackTrace.ToString());
            else if (logEvent.Exception != null)
                errorDetails.AppendFormat("<i>Stack Trace:</i><br />{0}<br /><br />", logEvent.Exception.Message + logEvent.Exception.StackTrace.ToString());

            // Server variables
            errorDetails.AppendFormat("<i>Server Variables:</i><br />");

            foreach (String s in serverVariables.AllKeys)
                errorDetails.AppendFormat("<p><span>{0,-10}<span>: <b>{1}</b></p>", s, serverVariables[s]);

            return errorDetails.ToString();
        }

 protected override void Write(NLog.Common.AsyncLogEventInfo logEvent)
 {
     if ( logEvent.LogEvent.Level > LogLevel.Warn && logEvent.LogEvent.Exception != null )
     {
         Elmah.ErrorSignal.FromCurrentContext().Raise(logEvent.LogEvent.Exception);
     }
 }

        protected override void Write(NLog.Common.AsyncLogEventInfo logEvent)
        {
            base.Write(logEvent);

            if (LogReceived != null)
                LogReceived(logEvent);
        }

        private LogEventInfo CreateLogEventInfo(NLog.LogLevel level, string message, IDictionary<string, object> dictionary, Exception exception)
        {
            LogEventInfo logEvent = new LogEventInfo(level, _logger.Name, message);

            foreach (var item in dictionary)
            {
                logEvent.Properties[item.Key] = item.Value;
            }

            if (exception != null)
            {
                logEvent.Properties["error-source"] = exception.Source;
                if (exception.TargetSite != null)
                {
                    if (exception.TargetSite.DeclaringType != null)
                    {
                        logEvent.Properties["error-class"] = exception.TargetSite.DeclaringType.FullName;
                    }
                    logEvent.Properties["error-method"] = exception.TargetSite.Name;

                }
                logEvent.Properties["error-message"] = exception.Message;

                if (exception.InnerException != null)
                {
                    logEvent.Properties["inner-error-message"] = exception.InnerException.Message;
                }
            }

            return logEvent;
        }

 public LumberjackMessageBuilder(NLog.Logger logger, string source, string appId, string component)
 {
     Logger = logger;
     Source = source;
     AppId = appId;
     Component = component;
 }

 protected override void Write(NLog.Common.AsyncLogEventInfo[] logEvents)
 {
     foreach (var ev in logEvents)
     {
         NumEvents++;
     }
 }

        protected override void Write(NLog.Common.AsyncLogEventInfo logEvent)
        {
            base.Write(logEvent);

            if (RecieveLog != null)
                RecieveLog(logEvent);
        }

		/// <summary>
		/// Instantiates an instance of the LoggerMark class.
		/// </summary>
		/// <param name="location">The location of the mark.</param>
		/// <param name="logger">The logger to log the mark to.</param>
		public LoggerMark(string location, NLog.Logger logger)
		{
			_id = _nextId++;
			_location = location;
			_logger = logger;
			_logger.Trace("Enter " + location + " : " + _id);
			_watch = Stopwatch.StartNew();
		}

		public PackageService(
			IServerPackageRepository repository,
			IPackageAuthenticationService authenticationService,
			NLog.ILogger logger)
		{
			_serverRepository = repository;
			_authenticationService = authenticationService;
			_logger = logger;
		}

 public static void Write(object element, int depth, NLog.Logger log)
 {
     if (log.IsTraceEnabled)
     {
         ObjectDumper dumper = new ObjectDumper(depth);
         dumper.WriteObject(null, element);
         log.Trace(dumper.builder);
     }
 }

		public DeployBatchRunner(NLog.Logger logger, ISystemSettings systemSettings, IDeployStateManager deployStateManager, IDeployRunner deployRunner, IDeployQueueManager deployQueueManager, IDeployRequestManager deployRequestManager, ICleanupManager cleanupManager)
		{
			_logger = DIHelper.VerifyParameter(logger);
			_systemSettings = DIHelper.VerifyParameter(systemSettings);
			_deployStateManager = DIHelper.VerifyParameter(deployStateManager);
			_deployRunner = DIHelper.VerifyParameter(deployRunner);
			_deployQueueManager = DIHelper.VerifyParameter(deployQueueManager);
			_deployRequestManager = DIHelper.VerifyParameter(deployRequestManager);
			_cleanupManager = DIHelper.VerifyParameter(_cleanupManager);
		}

 public LogEvent(NLog.LogEventInfo logEventInfo)
 {
     LoggerName = logEventInfo.LoggerName;
     TimeStamp = logEventInfo.TimeStamp;
     Level = logEventInfo.Level.ToString();
     LogMessage = logEventInfo.FormattedMessage;
     ToolTip = logEventInfo.FormattedMessage;
     Exception = logEventInfo.Exception;
     SetColors(logEventInfo);
 }

		protected override void Write(NLog.LogEventInfo logEvent) {
			var	msg = AppendException(logEvent.FormattedMessage, logEvent.Exception);
			
			_buffer.Add(new LogMessage {
				Level = logEvent.Level,
				Message = msg,
				Source = logEvent.LoggerName,
				Timestamp = logEvent.TimeStamp
			});	
		}

        protected override void Append(StringBuilder builder, NLog.LogEventInfo logEvent)
        {
            var actionName = string.Empty;
            if (HttpContext.Current != null)
            {
                actionName = HttpContext.Current.Request.RequestContext.RouteData.Values["action"].ToString();
            }

            builder.Append(actionName);
        }

		public DeployBatchParallelRunner(NLog.Logger logger, ISystemSettings systemSettings, IDeployStateManager deployStateManager, IDeployQueueManager deployQueueManager, IDeployRequestManager deployRequestManager, IDeploymentPlanBuilder deploymentPlanBuilder, IDIFactory diFactory, ICleanupManager cleanupManager)
		{
			_logger = DIHelper.VerifyParameter(logger);
			_systemSettings = DIHelper.VerifyParameter(systemSettings);
			_deployStateManager = DIHelper.VerifyParameter(deployStateManager);
			_deployQueueManager = DIHelper.VerifyParameter(deployQueueManager);
			_deployRequestManager = DIHelper.VerifyParameter(deployRequestManager);
			_deploymentPlanBuilder = DIHelper.VerifyParameter(deploymentPlanBuilder);
			_diFactory = DIHelper.VerifyParameter(diFactory);
			_cleanupManager = DIHelper.VerifyParameter(cleanupManager);
		}

        /// <summary>
        /// Indicates that new log information has been received.
        /// </summary>
        /// <param name="log">The log.</param>
        public void IndicateNewActivity(NLog.Common.AsyncLogEventInfo log)
        {
            this.logs.Add(log.LogEvent);
            NotifyOfPropertyChange(() => Logs);

            if (!this.IsActive)
            {
                HasUncheckedActivity = true;
                NotifyOfPropertyChange(() => HasUncheckedActivity);
            }
        }

 public void CheckPoint(NLog.Logger logger, string name = null)
 {
     CheckPoint(name);
     DateTime lastTime;
     if (currentPointsList.Count > 1)
         lastTime = currentPointsList[currentPointsList.Count - 2].Time;
     else
         lastTime = currentGroupLevels.Last().GroupStartTime.Value;
     logger.Debug("Замер производительности [{0}] +{1} секунд.", currentPointsList.Last().Name,
                 (currentPointsList.Last().Time - lastTime).TotalSeconds);
 }

 private void ConfigureLogger(NLog.LogLevel nlogLogLevel)
 {
     var config = new LoggingConfiguration();
     _target = new MemoryTarget {Layout = "${level:uppercase=true}|${message}|${exception}"};
     config.AddTarget("memory", _target);
     var loggingRule = new LoggingRule("*", NLog.LogLevel.Trace, _target);
     loggingRule.DisableLoggingForLevel(nlogLogLevel);
     config.LoggingRules.Add(loggingRule);
     LogManager.Configuration = config;
     _sut = new NLogLogProvider().GetLogger("Test");
 }

        public UsersController(IUOW uow, NLog.ILogger logger, ApplicationRoleManager roleManager, ApplicationSignInManager signInManager, ApplicationUserManager userManager, IAuthenticationManager authenticationManager)
        {
            _logger = logger;
            _roleManager = roleManager;
            _signInManager = signInManager;
            _userManager = userManager;
            _authenticationManager = authenticationManager;
            _uow = uow;

            _logger.Debug("InstanceId: " + _instanceId);
        }