public void Write(LogLevel level, LogEvent logEvent)
            {
                LogBuilder fluent;
                switch (level)
                {
                    case LogLevel.Trace:
                        fluent = _logger.Trace();
                        break;
                    case LogLevel.Info:
                        fluent = _logger.Info();
                        break;
                    case LogLevel.Warning:
                        fluent = _logger.Warn();
                        break;
                    case LogLevel.Error:
                        fluent = _logger.Error();
                        break;
                    case LogLevel.Critical:
                        fluent = _logger.Fatal();
                        break;
                    default:
                        throw new ApplicationException("Invalid log level");
                }

                if (!string.IsNullOrWhiteSpace(logEvent.Message))
                    fluent.Message(logEvent.Message);
                if (logEvent.Exception != null)
                    fluent.Exception(logEvent.Exception);
                foreach (var parameter in logEvent.Parameters)
                {
                    fluent.Property(parameter.Key, parameter.Value);
                }
                fluent.Write();
            }

        /// <summary>
        /// This version works with the OpenEngS 3.0.0-Snapshot Framwork
        /// </summary>
        /// <param name="args">System Arguments</param>
        static void Main(string[] args)
        {
            log4net.Config.BasicConfigurator.Configure();
            ILog logger = LogManager.GetLogger(typeof(ExampleDomainConnector));

            string destination = "tcp://localhost.:6549";
            string domainName = "example";
            logger.Info("Start Example wit the domain " + domainName);
            IExampleDomainSoap11Binding localDomain = new ExampleDomainConnector();
            IDomainFactory factory = DomainFactoryProvider.GetDomainFactoryInstance("3.0.0", destination, localDomain, EExceptionHandling.Retry);

            //Register the connecter on the OpenEngSB
            String serviceId = factory.CreateDomainService(domainName);
            factory.RegisterConnector(serviceId, domainName);

            IExampleDomainEventsSoap11Binding remotedomain = factory.getEventhandler<IExampleDomainEventsSoap11Binding>(domainName);
            LogEvent lEvent = new LogEvent();
            lEvent.name = "Example";
            lEvent.level = "DEBUG";
            lEvent.message = "remoteTestEventLog";
            remotedomain.raiseEvent(lEvent);
            logger.Info("Press enter to close the Connection");
            Console.ReadKey();
            factory.UnRegisterConnector(domainName);
            factory.DeleteDomainService(domainName);
            factory.StopConnection(domainName);
        }

        /// <summary>
        /// Emit the provided log event to the sink.
        /// </summary>
        /// <param name="logEvent">The log event to write.</param>
        public void Emit(LogEvent logEvent)
        {
            LogEventPropertyValue eventId;
            logEvent.Properties.TryGetValue("EventId", out eventId);

            LogEventPropertyValue hostName;
            logEvent.Properties.TryGetValue("Host", out hostName);

            LogEventPropertyValue url;
            logEvent.Properties.TryGetValue("RequestPath", out url);

            Message message = new Message(logEvent.RenderMessage(_formatProvider))
            {
                id = eventId?.ToString(),
                hostname = hostName?.ToString(),
                url = url?.ToString(),
                QueryString = RequestQueryToQuery(logEvent),
                Severity = LevelToSeverity(logEvent),
                DateTime = logEvent.Timestamp.DateTime.ToUniversalTime(),
                Detail = logEvent.Exception?.ToString(),
                Data = PropertiesToData(logEvent),
            };

            // Convert to json
            string messageJson = MessageToJson(message);

            // Call ElmhaIO     
            HttpClient client = new HttpClient();
            client.PostAsync([email protected]"https://elmah.io/api/v2/messages?logid={_logId}", new StringContent(messageJson, Encoding.UTF8, "application/json"));
        }

 public static void AddLogEvent(LogEvent logEvent)
 {
     if (!_activeLogEvents.Contains(logEvent))
     {
         _activeLogEvents.Add(logEvent);
     }
 }

        // Synchronous logging
        public override void Log(LogEvent logEvent)
        {
            // Lock, to keep our colors from getting messed up
            lock (_colorLock)
            {
                // Get a hold of the current colors
                var oldForeground = Console.ForegroundColor;
                var oldBackground = Console.BackgroundColor;

                try
                {
                    // Feedback loop prevention
                    var silent = logEvent != null && logEvent.Silent;

                    // Set the colors to our custom colors
                    Console.BackgroundColor = GetConsoleColor(logEvent, BackgroundColorMeta, ColorConfig.BackgroundColor, silent);
                    Console.ForegroundColor = GetConsoleColor(logEvent, ForegroundColorMeta, ColorConfig.ForegroundColor, silent);

                    // Write out our message
                    Console.Out.Write(Layout.FormatLogEvent(logEvent));
                }
                finally
                {
                    // Make sure we reset our colors
                    Console.ForegroundColor = oldForeground;
                    Console.BackgroundColor = oldBackground;
                }
            }
        }

 void LogEvent(LogEvent eventInfo)
 {
     if (eventInfo.Level == LogEventLevel.Verbose)
     {
         verboses.Add(eventInfo);
     }
     if (eventInfo.Level == LogEventLevel.Debug)
     {
         debugs.Add(eventInfo);
     }
     if (eventInfo.Level == LogEventLevel.Fatal)
     {
         fatals.Add(eventInfo);
     }
     if (eventInfo.Level == LogEventLevel.Error)
     {
         errors.Add(eventInfo);
     }
     if (eventInfo.Level == LogEventLevel.Information)
     {
         informations.Add(eventInfo);
     }
     if (eventInfo.Level == LogEventLevel.Warning)
     {
         warns.Add(eventInfo);
     }
 }

        public void Enrich(LogEvent e, out string propertyName, out object propertyValue)
        {
            var frame = new StackFrame(4);   //warning! this can change after refactoring

             propertyName = "method";

             MethodBase method = frame.GetMethod();
             var sb = new StringBuilder();

             sb.Append(method.DeclaringType.FullName);
             sb.Append(".");
             sb.Append(method.Name);
             sb.Append("(");
             bool isFirst = true;
             foreach(ParameterInfo p in method.GetParameters())
             {
            if (!isFirst)
            {
               sb.Append(", ");
            }
            else
            {
               isFirst = false;
            }
            sb.Append(p.ParameterType.Name);
            sb.Append(" ");
            sb.Append(p.Name);
             }
             sb.Append(")");

             propertyValue = sb.ToString();
        }

		protected override void WriteLine(string textLine, LogEvent logEvent)
		{
			if (logEvent.LogLevel == LogLevel.FatalError)
			{
				Android.Util.Log.Error(logEvent.AppName, textLine);
				return;
			}
			if (logEvent.LogLevel == LogLevel.Error)
			{
				Android.Util.Log.Error(logEvent.AppName, textLine);
				return;
			}
			if (logEvent.LogLevel == LogLevel.Warning)
			{
				Android.Util.Log.Warn(logEvent.AppName, textLine);
				return;
			}
			if (logEvent.LogLevel == LogLevel.Info)
			{
				Android.Util.Log.Info(logEvent.AppName, textLine);
				return;
			}
			if (logEvent.LogLevel == LogLevel.Debug)
			{
				Android.Util.Log.Debug(logEvent.AppName, textLine);
				return;
			}
			if (logEvent.LogLevel == LogLevel.Verbose)
			{
				Android.Util.Log.Verbose(logEvent.AppName, textLine);
				return;
			}
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="LogBatchEntry" /> class.
 /// </summary>
 /// <param name="log">The log.</param>
 /// <param name="message">The message.</param>
 /// <param name="logEvent">The log event.</param>
 /// <param name="extraData">The extra data.</param>
 public LogBatchEntry(ILog log, string message, LogEvent logEvent, object extraData)
 {
     Log = log;
     Message = message;
     LogEvent = logEvent;
     ExtraData = extraData;
 }

    void LogMessage(string message, LogEvent logEvent)
    {
        if (logEvent == LogEvent.Error)
        {
            Errors.Add(message);
            return;
        }
        if (logEvent == LogEvent.Warning)
        {
            Warnings.Add(message);
            return;
        }
        if (logEvent == LogEvent.Info)
        {
            Informations.Add(message);
            return;
        }
        if (logEvent == LogEvent.Debug)
        {
            Debugs.Add(message);
// ReSharper disable once RedundantJumpStatement
            return;
        }

    }

        public void Emit(LogEvent logEvent)
        {
            if (logEvent == null) throw new ArgumentNullException("logEvent");

            lock (syncRoot)
            {
                if (disposed)
                {
                    throw new ObjectDisposedException(ThisObjectName, "Cannot write to disposed file");
                }

                if (output == null)
                {
                    return;
                }

                formatter.Format(logEvent, output);
                output.Flush();

                this.ActiveLogLevel = logEvent.Level;

                if (output.BaseStream.Length > fileSizeLimitBytes)
                {
                    sizeLimitReached = true;
                }
            }
        }

        /// <summary>
        /// Called when any message is written to the log.
        /// </summary>
        /// <param name="log">The log.</param>
        /// <param name="message">The message.</param>
        /// <param name="logEvent">The log event.</param>
        /// <param name="extraData">The additional data.</param>
        /// <param name="time">The time.</param>
        protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, System.DateTime time)
        {
            base.Write(log, message, logEvent, extraData, time);

            switch (logEvent)
            {
                case LogEvent.Debug:
                    _eventSource.Debug(message);
                    break;

                case LogEvent.Info:
                    _eventSource.Info(message);
                    break;

                case LogEvent.Warning:
                    _eventSource.Warning(message);
                    break;

                case LogEvent.Error:
                    _eventSource.Error(message);
                    break;

                default:
                    throw new ArgumentOutOfRangeException("logEvent");
            }
        }

 public override void Log(LogEvent oEvent)
 {
     m_oEventLog.Source = this.AppName;
     m_oEventLog.WriteEntry(oEvent.Message, GetEventEntryType(oEvent.Level), oEvent.ID);
     //test exception
     //throw new Exception("test exp from WindowsEventHandler class");
 }

            protected override void Write(ILog log, string message, LogEvent logEvent, object extraData, LogData logData, DateTime time)
            {
                if (log.TargetType != typeof(TestLogListener))
                {
                    return;
                }

                switch (logEvent)
                {
                    case LogEvent.Debug:
                        DebugCount++;
                        break;

                    case LogEvent.Info:
                        InfoCount++;
                        break;

                    case LogEvent.Warning:
                        WarningCount++;
                        break;

                    case LogEvent.Error:
                        ErrorCount++;
                        break;

                    case LogEvent.Status:
                        StatusCount++;
                        break;
                }
            }

 /// <summary>
 /// Creates a new SmtpLogEventBuilder based on the passed log event
 /// </summary>
 /// <param name="logEvent">The log event to use as a base</param>
 /// <returns>A new instance of SmtpLogEventBuilder</returns>
 public static EmailLogEventBuilder Create(LogEvent logEvent)
 {
     return new EmailLogEventBuilder
     {
         LogEvent = logEvent
     };
 }

        private static void UpdateConsoleColors(LogEvent logEvent)
        {
            var colorSet = ColorSets[logEvent];

            Console.BackgroundColor = colorSet.Background;
            Console.ForegroundColor = colorSet.Foreground;
        }

        /// <summary>
        /// Called when any message is written to the log.
        /// </summary>
        /// <param name="log">The log.</param>
        /// <param name="message">The message.</param>
        /// <param name="logEvent">The log event.</param>
        /// <param name="extraData">The extra data.</param>
        protected override void Write(ILog log, string message, LogEvent logEvent, object extraData)
        {
            string consoleMessage = string.Format("{0} => [{1}] {2}", DateTime.Now.ToString("hh:mm:ss:fff"),
                logEvent.ToString().ToUpper(), message);

#if NETFX_CORE
            System.Diagnostics.Debug.WriteLine(consoleMessage);
#elif WINDOWS_PHONE
            System.Diagnostics.Debug.WriteLine(consoleMessage);
#elif SL4 || SL5
            if (InitializeConsole())
            {
                _dispatcher.BeginInvoke(() => _console.InvokeSelf(consoleMessage));
            }
#elif NET
            switch (logEvent)
            {
                case LogEvent.Debug:
                    System.Diagnostics.Trace.WriteLine(consoleMessage);
                    break;

                case LogEvent.Info:
                    System.Diagnostics.Trace.TraceInformation(consoleMessage);
                    break;

                case LogEvent.Warning:
                    System.Diagnostics.Trace.TraceWarning(consoleMessage);
                    break;

                case LogEvent.Error:
                    System.Diagnostics.Trace.TraceError(consoleMessage);
                    break;
            }
#endif
        }

		protected override void WriteLine(string textLine, LogEvent logEvent)
		{
			if (_activity == null)
				return;

			_activity.RunOnUiThread(() =>
			{
			    try
			    {
                    var adBuilder = new AlertDialog.Builder(_activity);
                    adBuilder.SetTitle(string.Format("LogWriter: {0}", logEvent.Logger.LoggingType.Name));
                    adBuilder.SetMessage(textLine);
                    adBuilder.SetNegativeButton("OK", (s, e) =>
                    {
                        var alertDialog = s as AlertDialog;
                        if (alertDialog != null)
                        {
                            alertDialog.Dismiss();
                            alertDialog.Cancel();
                        }
                    });

                    adBuilder.Create().Show();
			    }
			    catch (Exception e)
			    {
                    // TODO detta måste fixas
			        // something went terribly wrong
			    }
				
			});
		}

 public override void Log(LogEvent logEvent)
 {
     lock (_listLock)
     {
         _logEvents.Add(logEvent);
     }
 }

        private void WriteToFile(LogEvent logEvent)
        {
            lock (this.syncRoot)
            {
                if (this.disposed)
                {
                    throw new ObjectDisposedException(ThisObjectName, "The rolling file sink has been disposed");
                }

                var resetSequence = currentSink.LogFile.Date.Date != DateTime.UtcNow.Date;

                if (currentSink.EnableLevelLogging && currentSink.ActiveLogLevel != logEvent.Level)
                {
                    currentSink = NextSizeLimitedFileSink(resetSequence, logEvent.Level);
                }

                if (currentSink.SizeLimitReached || resetSequence)
                {
                    currentSink = NextSizeLimitedFileSink(resetSequence, logEvent.Level);
                    ApplyRetentionPolicy(roller.LogFileDirectory);
                }

                if (this.currentSink != null)
                {
                    this.currentSink.Emit(logEvent);
                }
            }
        }