public static AssetLogMessage From(Package package, IReference assetReference, ILogMessage logMessage, string assetPath, int line = 0, int character = 0)
        {
            // Transform to AssetLogMessage
            var assetLogMessage = logMessage as AssetLogMessage;
            if (assetLogMessage == null)
            {
                assetLogMessage = new AssetLogMessage(null, assetReference, logMessage.Type, AssetMessageCode.CompilationMessage, assetReference?.Location, logMessage.Text)
                {
                    Exception = (logMessage as LogMessage)?.Exception
                };
            }

            // Set file (and location if available)
            assetLogMessage.File = assetPath;
            assetLogMessage.Line = line;
            assetLogMessage.Character = character;

            // Generate location (if it's a Yaml exception)
            var yamlException = (logMessage as LogMessage)?.Exception as YamlException;
            if (yamlException != null)
            {
                assetLogMessage.Line = yamlException.Start.Line;
                assetLogMessage.Character = yamlException.Start.Column;
                // We've already got everything, no need to pollute log with stack trace of exception
                assetLogMessage.Exception = null;
            }

            return assetLogMessage;
        }

        protected override void OnLog(ILogMessage logMessage)
        {
            // Always log when debugger is attached
            if (logMessage.Type < LogLevel)
            {
                return;
            }

            var color = ConsoleColor.Gray;

            // set the color depending on the message log level
            switch (logMessage.Type)
            {
                case LogMessageType.Debug:
                    color = ConsoleColor.DarkGray;
                    break;
                case LogMessageType.Verbose:
                    color = ConsoleColor.Gray;
                    break;
                case LogMessageType.Info:
                    color = ConsoleColor.Green;
                    break;
                case LogMessageType.Warning:
                    color = ConsoleColor.Yellow;
                    break;
                case LogMessageType.Error:
                case LogMessageType.Fatal:
                    color = ConsoleColor.Red;
                    break;
            }

            logger(GetDefaultText(logMessage), color);
        }

        /// <inheriteddoc />
        protected override void OnLog(ILogMessage msg, ref bool success)
        {
            var sb = new StringBuilder();
            CreateString(msg, sb);

            Debug.WriteLine(sb.ToString());
        }

        protected override void ExportLogMessage(IRepositoryContext context, ISession session, ILogMessage message)
        {
            WriteLine(); 
            if (message.Severity == LogMessageSeverity.Verbose)
                Write("{0} {1}\r\n", message.Timestamp, message.Caption.Trim());
            else
            {
                var severity = message.Severity.ToString();
                if (severity.StartsWith("Info") || severity.StartsWith("Warn"))
                    severity = severity.Substring(0, 4);
                else
                    severity = severity.ToUpperInvariant();

                Write("{0} {2} {1}\r\n", message.Timestamp, message.Caption.Trim(), severity);
            }
            if (string.IsNullOrEmpty(message.Description) == false)
            {
                Write("{0}\r\n", message.Description.Trim());
            }
            Write("Category: {0} from {1}", message.CategoryName, message.LogSystem);

            if (string.IsNullOrEmpty(message.ClassName) == false)
            {
                Write("  {0}.{1}", message.ClassName, message.MethodName);
            }

            if (string.IsNullOrEmpty(message.FileName) == false)
            {
                Write(" in {0} ({1})", message.FileName, message.LineNumber);
            }
            WriteLine();

            Write("Thread: {0} ({1}) for {2}\r\n", message.ThreadName, message.ThreadId, message.UserName);

            IExceptionInfo currentException = message.Exception;
            if (currentException != null)
            {
                if (Config.IncludeExceptionDetails)
                {
                    var label = "EXCEPTION";
                    while (currentException != null)
                    {
                        Write("{0}: {1} - {2} from {3}\r\nStack Trace:\r\n{4}\r\n",
                            label, currentException.TypeName, currentException.Message.Trim(),
                            currentException.Source, currentException.StackTrace);
                        currentException = currentException.InnerException;
                        label = "INNER EXCEPTION";
                    }
                }
                else
                {
                    while (currentException != null)
                    {
                        Write("{0}: {1}\r\n", currentException.TypeName, currentException.Message.Trim());
                        currentException = currentException.InnerException;
                    }
                }
                WriteLine();
            }
        }

        protected override void LogRaw(ILogMessage logMessage)
        {
            buildStep.Logger.Log(logMessage);

            mainLogger?.Log(logMessage);
            StepLogger?.Log(logMessage);
        }

        protected override void OnLog(ILogMessage message)
        {
            var serializableMessage = message as SerializableLogMessage;
            if (serializableMessage == null)
            {
                var assetMessage = message as AssetLogMessage;
                if (assetMessage != null)
                {
                    assetMessage.Module = mainLogger.Module;
                    serializableMessage = new AssetSerializableLogMessage(assetMessage);
                }
                else
                {
                    var logMessage = message as LogMessage;
                    serializableMessage = logMessage != null ? new SerializableLogMessage(logMessage) : null;
                }
            }

            if (serializableMessage == null)
            {
                throw new ArgumentException(@"Unable to process the given log message.", "message");
            }

            foreach (var remoteLog in remoteLogs)
            {
                try
                {
                    remoteLog.ForwardSerializableLog(serializableMessage);
                }
                // ReSharper disable EmptyGeneralCatchClause
                catch { }
                // ReSharper restore EmptyGeneralCatchClause
            }
        }

 private void Log(ILogMessage obj)
 {
     if (MessageLogged != null)
     {
         MessageLogged(obj);
     }
 }

        public CLogMessage(
            IMessageSerializer messageSerializer,

            DateTime timeStamp,
            LogMessageCategoryEnum messageCategory,
            bool isException,
            bool isRootMessage,
            string source,
            string message,
            string messageStackTrace,
            string exceptionStackTrace,

            ILogMessage childMessage
            )
        {
            if (messageSerializer == null)
            {
                throw new ArgumentNullException("messageSerializer");
            }
            //childMessage allowed to be null

            _messageSerializer = messageSerializer;

            _timeStamp = timeStamp;
            _messageCategory = messageCategory;
            _isException = isException;
            _isRootMessage = isRootMessage;
            _source = source;
            _message = message.CrLnNormalize();
            _messageStackTrace = messageStackTrace.CrLnNormalize();
            _exceptionStackTrace = exceptionStackTrace.CrLnNormalize();

            _childMessage = childMessage;
        }

 private void OnMessageLogged(ILogMessage msg)
 {
     if (this.MessageLogged != null)
     {
         this.MessageLogged(msg);
     }
 }

 /// <inheriteddoc />
 protected sealed override void OnLog(ILogMessage msg, ref bool success)
 {
     lock (SyncRoot)
     {
         base.OnLog(msg, ref success);
     }
 }

		public void Add(ILogMessage item)
		{
			lock(syncObj) //We can just lock because we don't lock anymore while taking. Deadlocks used to occur before, and the fix didn't work 100%, so we now don't lock on Take().
							//We were able to do it lockless because we caught dipose and cancel exceptions and continued on them. There is little to no contention on syncObj anymore.
			{
				messageCollection.Add(item);
			}
		}

 protected override void LogRaw(ILogMessage logMessage)
 {
     TimeSpan timestamp = DateTime.Now - startTime;
     lock (Messages)
     {
         Messages.Add(new Message(timestamp.Ticks, logMessage));
     }
 }

 protected override void OnLog(ILogMessage logMessage)
 {
     Debug.WriteLine(GetDefaultText(logMessage));
     var exceptionMsg = GetExceptionText(logMessage);
     if (!string.IsNullOrEmpty(exceptionMsg))
     {
         Debug.WriteLine(exceptionMsg);
     }
 }

        protected override void OnLog(ILogMessage message)
        {
            if (!activeRemoteLogs)
                return;

            var serializableMessage = message as SerializableLogMessage;
            if (serializableMessage == null)
            {
                var assetMessage = message as AssetLogMessage;
                if (assetMessage != null)
                {
                    assetMessage.Module = mainLogger.Module;
                    serializableMessage = new AssetSerializableLogMessage(assetMessage);
                }
                else
                {
                    var logMessage = message as LogMessage;
                    serializableMessage = logMessage != null ? new SerializableLogMessage(logMessage) : null;
                }
            }

            if (serializableMessage == null)
            {
                throw new ArgumentException(@"Unable to process the given log message.", "message");
            }

            for (int i = 0; i < remoteLogs.Count; i++)
            {
                var remoteLog = remoteLogs[i];
                try
                {
                    remoteLog?.ForwardSerializableLog(serializableMessage);
                }
                    // ReSharper disable EmptyGeneralCatchClause
                catch
                {
                    // Communication failed, let's null it out so that we don't try again
                    remoteLogs[i] = null;
                    TryCloseChannel(remoteLog);

                    // Check if we still need to log anything
                    var newActiveRemoteLogs = false;
                    for (int j = 0; j < remoteLogs.Count; j++)
                    {
                        if (remoteLogs[j] != null)
                        {
                            newActiveRemoteLogs = true;
                            break;
                        }
                    }

                    activeRemoteLogs = newActiveRemoteLogs;
                }
                // ReSharper restore EmptyGeneralCatchClause
            }
        }

        }// end constructeur




        /// <summary>
        /// Enregistre Le message dans un fichier de Log
        /// </summary>
        /// <param name="MonLevel">Niveau de criticité</param>
        /// <param name="MonMessage">Message à enresgitrer</param>
        /// <param name="MonContexte">Contexte d'exécution</param>
        public override void SendMessage(LogLevel MonLevel, ILogMessage MonMessage, ILogContexte MonContexte)
        {


            DBCnx curCon = DbCnxManager.CreateConnectionFromConnectingString(ConnectionString);

            curCon.SQL_Execute("PR_LOG_MESSAGE", "@LOG_LEVEL", MonLevel, "@Origin", MonContexte.Origin, "@scope", MonContexte.Scope, "@loguser", MonContexte.CurrentUser
                , "@domaine", MonMessage.Domaine, "@MESSAGE_NUMBER", MonMessage.NumMessage, "@LOG_MESSAGE", MonMessage.TexteMessage, "@OTHERSINFOS", JsonConvert.SerializeObject(MonContexte.InfosComplementaires));
            curCon.Dispose();
        }

 protected override void LogRaw(ILogMessage logMessage)
 {
     base.LogRaw(logMessage);
     if (loggerToForward != null)
     {
         lock (loggerToForward)
         {
             loggerToForward.Log(logMessage);
         }
     }
 }

 private static string FormatLog(ILogMessage message)
 {
     //$filename($row,$column): $error_type $error_code: $error_message
     //C:\Code\Paradox\sources\assets\SiliconStudio.Assets.CompilerApp\PackageBuilder.cs(89,13,89,70): warning CS1717: Assignment made to same variable; did you mean to assign something else?
     var builder = new StringBuilder();
     builder.Append(message.Module);
     builder.Append(": ");
     builder.Append(message.Type.ToString().ToLowerInvariant()).Append(" ");
     builder.Append((clock.ElapsedMilliseconds * 0.001).ToString("0.000"));
     builder.Append("s: ");
     builder.Append(message.Text);
     return builder.ToString();
 }

        /// <summary>
        /// Return a unique fingerprint string for this message (presumably an error)
        /// </summary>
        /// <remarks>
        /// <para>This is an important method.  Think of the fingerprint like a hashcode.
        /// All instances of the same logical error should have the same fingerprint.
        /// Each unique error should have a unique fingerprint.
        /// </para>
        /// <para>This implementation makes the reasonably good assumption that a fingerprint
        /// should be based on product + application + caption + classname + category.</para>
        /// <para>There are three main weaknesses to this approach:</para>
        /// <para>1. If the caption varies across instances, each will be assigned
        /// a unique fingerprint. To minimize this, make sure to put all dynamic fields such as
        /// parameter values in the message description, not the caption.</para>
        /// <para>2. Localization. If the caption is localized, each language will result
        /// in a unique fingerprint.</para>
        /// <para>3. If the caption is too generic (ex., null reference exception) different
        /// errors might be erroneously grouped together.</para>
        /// </remarks>
        private static string GetFingerprint(ILogMessage message)
        {
            ISessionSummary summary = message.Session.Summary;
            StringBuilder builder = new StringBuilder();
            builder.AppendFormat("Loupe Error Fingerprint:\r\n");
            builder.AppendFormat("Product: {0}\r\n", summary.Product);
            builder.AppendFormat("Application: {0}\r\n", summary.Application);
            builder.AppendFormat("Caption: {0}\r\n", message.Caption);
            builder.AppendFormat("ClassName: {0}\r\n", message.ClassName);
            builder.AppendFormat("Category: {0}\r\n", message.CategoryName);

            string hash = GetHash(builder.ToString());
            return hash;
        }

        /// <inheriteddoc />
        protected override void OnLog(ILogMessage msg, ref bool success)
        {
            var handler = MessageReceived;
            if (handler == null)
            {
                return;
            }

            var e = new LogEventArgs(msg)
                {
                    Handled = true,
                };
            handler(this, e);

            success = e.Handled;
        }

        protected override void LogRaw(ILogMessage logMessage)
        {
            buildStep.Logger.Log(logMessage);

            if (mainLogger != null)
            {
                mainLogger.Log(logMessage);
            }
            if (StepLogger != null)
            {
                lock (StepLogger)
                {
                    StepLogger.Log(logMessage);
                }
            }
        }