public LogMessage(string msg)
 {
     this.level = LogLevels.Verbose;
     this.msgText = msg;
     this.subject = "unknown";
     this.created = DateTime.Now;
 }

 public static void LogFile(string entry, LogLevels level)
 {
     if (Silent)
     {
         return;
     }
     if (CurrentLevel > (byte)level)
     {
         return;
     }
     entry = DateTime.Now.TimeOfDay.ToString() + " " + Convert.ToString(Thread.CurrentThread.ManagedThreadId) + " " + entry;
     Queue.Synchronized(logEntriesList).Enqueue(entry);
     Monitor.Enter(logThread);
     if(!logThread.IsAlive)
     {
         logThread.Start();
     }
     Monitor.Exit(logThread);
     try
     {
         sm.Release();
     }
     catch
     {
     }
 }

 public void Log(LogLevels logLevel, string str)
 {
     using (var sw = GetStreamWriter())
     {
         sw.WriteLine("{0}:{1:HH-mm-ss}: {2}", logLevel, DateTime.Now, str);
     }
 }

 public static void LogWithTags(this ExceptionlessClient client, string logMessage, string[] tags, string source = null, LogLevels level = LogLevels.Info)
 {
     if (client.LoggingEnabled())
         client.CreateLog(source, logMessage, level.Text())
             .AddTags(tags)
             .Submit();
 }

		public void WriteText(System.IO.TextWriter writer, LogLevels level, DateTime dateTime, string text)
		{
			string sLevel;
			switch (level)
			{
				case LogLevels.Info:
				default:
					sLevel = "I";
					break;

				case LogLevels.Diagnostic:
					sLevel = "D";
					break;

				case LogLevels.Warning:
					sLevel = "W";
					break;

				case LogLevels.Error:
					sLevel = "E";
					break;
			}

			writer.WriteLine("{0}:{1} {2} [{4}]: {3}",
				sLevel, dateTime.ToShortDateString(), dateTime.ToLongTimeString(),
				text, Thread.CurrentThread.GetHashCode());
		}

 public void AppendEntry(string sourceDomainName, global::System.Reflection.AssemblyName sourceAssembly, string sourceTypeName, string sourceMethodName, LogLevels level, DateTime timestamp, string message)
 {
     _logController.AppendEntry(sourceDomainName, sourceAssembly, sourceTypeName, sourceMethodName, level, timestamp, message);
     System.sDomain[] doms = System.Domains;
     foreach (System.sDomain dom in doms)
         dom.Core.AppendEntry(sourceDomainName, sourceAssembly, sourceTypeName, sourceMethodName, level, timestamp, message);
 }

        public static void Log(LogLevels level, string text)
        {
#if LOG
            if (!File.Exists(LogPath))
            {
                File.WriteAllText(LogPath, "Executable: " + Application.ExecutablePath + "\r\n" +
                    "Version: " + Application.ProductVersion + "\r\n" +
                    "Installed .Net Framework: " + typeof(object).Assembly.GetName().Version.ToString() + "\r\n" +
                    "OS: " + Environment.OSVersion.VersionString + "\r\n", Encoding.UTF8);
            }
            switch (level)
            {
                case LogLevels.Warning:
                    text = "[WARN] " + text;
                    break;
                case LogLevels.Error:
                    text = "[ERRO] " + text;
                    break;
                case LogLevels.Information:
                default:
                    text = "[INFO] " + text;
                    break;
            }
            File.AppendAllLines(LogPath, new string[] { text }, Encoding.UTF8);
#endif
        }

		/// <summary>
		/// To record a message to the log.
		/// </summary>
		/// <param name="receiver">Logs receiver.</param>
		/// <param name="level">The level of the log message.</param>
		/// <param name="getMessage">The function returns the text for <see cref="LogMessage.Message"/>.</param>
		public static void AddLog(this ILogReceiver receiver, LogLevels level, Func<string> getMessage)
		{
			if (receiver == null)
				throw new ArgumentNullException(nameof(receiver));

			receiver.AddLog(new LogMessage(receiver, receiver.CurrentTime, level, getMessage));
		}

        /// <summary>
        /// Writes a message to the log file.
        /// </summary>
        /// <param name="message">The message to write.</param>
        /// <param name="level">The level of severity of the log message.</param>
        public void Write(string message, LogLevels level)
        {
            lock (_lockObject)
            {
                if (_logLevel < level)
                {
                    // This message is more detailed than the user wants logged.
                    return;
                }

                if (string.IsNullOrEmpty(_filename))
                {
                    return;
                }

                using (var file = new StreamWriter(_filename, true))
                {
                    file.WriteLine(
                        string.Concat(
                            DateTime.UtcNow.ToString("M/d/yyyy HH:mm:ss"),
                            " Level ",
                            Enum.GetName(typeof(LogLevels), level),
                            ": ",
                            message));
                }
            }
        }

        private static void WriteLog(LogLevels level, string message)
        {
            if (!Directory.Exists(LogFolder))
            {
                Directory.CreateDirectory(LogFolder);
            }

            if (level >= Settings.settingsStore.logLevel)
            {
                string output;
                if (Settings.settingsStore.useUTCTimeInLog)
                {
                    output = "[" + DateTime.UtcNow.ToString("HH:mm:ss") + "][" + level.ToString() + "] : " + message;
                }
                else
                {
                    output = "[" + DateTime.Now.ToString("HH:mm:ss") + "][" + level.ToString() + "] : " + message;
                }
                Console.WriteLine(output);
                ClientHandler.SendConsoleMessageToAdmins(output);
                try
                {
                    lock (logLock) {
                        File.AppendAllText(LogFilename, output + Environment.NewLine);
                    }
                }
                catch (Exception e)
                {
                    Console.ForegroundColor = ConsoleColor.DarkRed;
                    Console.WriteLine("Error writing to log file!, Exception: " + e);
                    Console.ForegroundColor = ConsoleColor.Gray;
                }
            }
        }

 private static void LogLine(LogLevels level, string message)
 {
     if ((Level & level) == level)
     {
         LogStream.WriteLine(message);
     }
 }

        /// <summary>
        /// Static function used to log textual information to the console output.
        /// </summary>
        /// <param name="it"></param>
        /// <param name="text"></param>
        /// <param name="level"></param>
        internal static void Write(object it, string text, LogLevels level)
        {
            string label = "";

            if (level > Level)
                return;

            switch (level)
            {
                case LogLevels.Debug:
                    label = "[DEBUG] ";
                    break;

                case LogLevels.Error:
                    label = "[ERROR] ";
                    break;

                case LogLevels.Info:
                    break;

                case LogLevels.Warning:
                    label = "[WARNING] ";
                    break;
            }

            if (it == null)
                Console.WriteLine(label + text);
            else
                Console.WriteLine(it.GetType().Name + ": " + label + text);
        }

        protected override void WriteLog(LogLevels logLevel, string logRecord)
        {
            if (!Preferences.AutoLog) return;
            
            // 20140317
            // turning off the logger
//            switch (logLevel) {
//                case LogLevels.Fatal:
//                    Logger.Fatal(logRecord);
//                    break;
//                case LogLevels.Error:
//                    Logger.Error(logRecord);
//                    break;
//                case LogLevels.Warn:
//                    Logger.Warn(logRecord);
//                    break;
//                case LogLevels.Info:
//                    Logger.Info(logRecord);
//                    break;
//                case LogLevels.Debug:
//                    Logger.Debug(logRecord);
//                    break;
//                case LogLevels.Trace:
//                    Logger.Trace(logRecord);
//                    break;
//            }
        }

        public static void VisualLog(LogLevels loglevel, string type, String ex)
        {
            // create output to console
            TextWriterTraceListener console = new TextWriterTraceListener();
            console.Writer = Console.Out;
            Trace.Listeners.Add(console);
            //output error
            if (System.Diagnostics.Trace.Listeners.Count > 0)
            {
                Trace.Write(new TraceData(loglevel, DateTime.Now, type, ex));
            }
            //close streams
            console.Close();

            if (!ApplicationType.GetApplicationType().Equals(ApplicationType.Type.Console))
            {
                //messagebox
                MessageBoxIcon icon = MessageBoxIcon.None;
                switch (loglevel)
                {
                    case LogLevels.Error:
                        icon = MessageBoxIcon.Error;
                        break;
                    case LogLevels.Warning:
                        icon = MessageBoxIcon.Warning;
                        break;
                    case LogLevels.Info:
                        icon = MessageBoxIcon.Information;
                        break;
                }
                MessageBox.Show(ex, type, MessageBoxButtons.OK, icon);
            }
        }

 /// <summary>
 /// Logs a message to the database logger.
 /// If logger not defined, logs to the console.
 /// </summary>
 public static void AltLog(LogLevels eventType, int id, string message, bool forceconsole = false)
 {
     if (!forceconsole && Logger != null)
         Logger.TraceEvent(eventType, id, message);
     else
         Console.WriteLine(eventType.ToString() + " " + id + " " + LMLoggers.LognLM.FlattenChars(message));
 }

 protected void WriteLog(LogLevels logLevel, System.Management.Automation.ErrorRecord errorRecord)
 {
     if (Preferences.AutoLog) {
         
         this.WriteLog(logLevel, errorRecord.Exception.Message);
         this.WriteLog(logLevel, "Script: '" + errorRecord.InvocationInfo.ScriptName + "', line: " + errorRecord.InvocationInfo.Line.ToString());
     }
 }

 private static void LogMessage(LogLevels level, string message)
 {
     if (_writer != null)
     {
         if ((int)_writer.LogLevel >= (int)level)
             _writer.WriteLogMessage(DateTime.Now, level, message);
     }
 }

 protected void WriteLog(LogLevels logLevel, ErrorRecord errorRecord)
 {
     //if (Preferences.AutoLog) {
         
     WriteLog(logLevel, errorRecord.Exception.Message);
     WriteLog(logLevel, "Script: '" + errorRecord.InvocationInfo.ScriptName + "', line: " + errorRecord.InvocationInfo.Line.ToString());
     //}
 }

		/// <summary>
		/// Log the message to each of the logs in the list.
		/// </summary>
		/// <param name="level">Level of the message.</param>
		/// <param name="sMsg">Message to send.</param>
		public virtual void Log(LogLevels level, string sMsg, params Object[] args)
		{
			// Send the message to each log
			foreach(ILog log in _logs)
			{
				log.Log(level, sMsg, args);
			}
		}

		public void Log(DateTime date, LogLevels level, Dictionary<string, object> data, string sFormat, params object[] args)
		{
			// Send the message to each log
			foreach (ILog log in _logs)
			{
				log.Log(date, level, data, sFormat, args);
			}
		}