//******************************************************************************************************//  LogMessage.cs - Gbtc////  Copyright © 2016, Grid Protection Alliance.  All Rights Reserved.////  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See//  the NOTICE file distributed with this work for additional information regarding copyright ownership.//  The GPA licenses this file to you under the Eclipse Public License -v 1.0 (the "License"); you may//  not use this file except in compliance with the License. You may obtain a copy of the License at:////      http://www.opensource.org/licenses/eclipse-1.0.php////  Unless agreed to in writing, the subject software distributed under the License is distributed on an//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the//  License for the specific language governing permissions and limitations.////  Code Modification History://  ----------------------------------------------------------------------------------------------------//  10/24/2016 - Steven E. Chisholm//       Generated original version of source code. //       ////****************************************************************************************************** using System;using System.Data;using System.IO;using System.Reflection;using System.Text;using System.Threading;using GSF.Immutable;using GSF.IO; namespace GSF.Diagnostics{    /// <summary>    /// An individual log message.    /// </summary>    public sealed class LogMessage    {        /// <summary>        /// Contains details about the <see cref="LogEventPublisher"/> that published this <see cref="LogMessage"/>.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public readonly LogEventPublisherDetails EventPublisherDetails;         /// <summary>        /// The message stack that existed when the <see cref="LogPublisher"/> was originally constructed.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public readonly LogStackMessages InitialStackMessages;         /// <summary>        /// The stack trace that existed when the <see cref="LogPublisher"/> was originally constructed.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public readonly LogStackTrace InitialStackTrace;         /// <summary>        /// The message stack that existed when this <see cref="LogMessage"/> was published.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public readonly LogStackMessages CurrentStackMessages;         /// <summary>        /// The stack trace that existed when this <see cref="LogMessage"/> was published.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public readonly LogStackTrace CurrentStackTrace;         /// <summary>        /// The time that the message was created.        /// </summary>        public readonly DateTime UtcTime;         /// <summary>        /// The classification of the message        /// </summary>        public MessageClass Classification => LogMessageAttributes.Classification;         /// <summary>        /// The level associated with the message        /// </summary>        public MessageLevel Level => LogMessageAttributes.Level;         /// <summary>        /// The flags associated with the message        /// </summary>        public MessageFlags Flags => LogMessageAttributes.Flags;         /// <summary>        /// The suppression level assigned to this log message        /// </summary>        public MessageSuppression MessageSuppression => LogMessageAttributes.MessageSuppression;         /// <summary>        /// The <see cref="Type"/> associated with <see cref="LogPublisher"/> that generated the message.        /// </summary>        public string TypeName => EventPublisherDetails.TypeData.TypeName;         /// <summary>        /// The <see cref="Assembly"/> associated with <see cref="LogPublisher"/> that generated the message.        /// </summary>        public string AssemblyName => EventPublisherDetails.TypeData.AssemblyName;         /// <summary>        /// All related types such as interfaces/parent classes for the current type.        /// </summary>        public ImmutableList<string> RelatedTypes => EventPublisherDetails.TypeData.RelatedTypes;         /// <summary>        /// The event name of this log message.        /// </summary>        public string EventName => EventPublisherDetails.EventName;         internal readonly LogMessageAttributes LogMessageAttributes;         /// <summary>        /// A specific message about the event giving more specifics about the actual message.         /// Typically, this will be up to 1 line of text.         /// Can be String.Empty.        /// </summary>        public readonly string Message;         /// <summary>        /// A long text field with the details of the message.         /// Can be String.Empty.        /// </summary>        public readonly string Details;         /// <summary>        /// An exception object if one is provided.        /// Can be null.         /// Since the exception is not serialized to the disk, it will be null when loaded.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public readonly Exception Exception;         /// <summary>        /// A string representation of the exception. Can be String.Empty.        /// If loaded from the disk, since exception objects cannot be serialized,         /// the <see cref="Exception"/> will be null and         /// this field will have the string representation of <see cref="Exception"/>        /// </summary>        public readonly string ExceptionString;         /// <summary>        /// The Managed Thread ID of the thread that created this message. This         /// is primarily to assist in future log viewing applications        /// where it is beneficial to track the thread.        /// </summary>        public readonly int ManagedThreadID;         /// <summary>        /// A sequence number maintained by each thread thread of the previous         /// first chance exception that was thrown. This is used to assist        /// LogFileViewer associate log messages with properly handled         /// first chance exceptions.        /// </summary>        public readonly int PreviousFirstChanceExceptionSequenceNumber;         /// <summary>        /// Loads a log messages from the supplied stream        /// </summary>        /// <param name="stream">the stream to load the log message from.</param>        /// <param name="saveHelper">A save helper that will condense objects</param>        internal LogMessage(Stream stream, LogMessageSaveHelper saveHelper = null)        {            if (saveHelper == null)                saveHelper = LogMessageSaveHelper.Create(true);             byte version = stream.ReadNextByte();            switch (version)            {                case 1:                    EventPublisherDetails = saveHelper.LoadEventPublisherDetails(stream);                    InitialStackMessages = saveHelper.LoadStackMessages(stream);                    InitialStackTrace = saveHelper.LoadStackTrace(stream);                    CurrentStackMessages = saveHelper.LoadStackMessages(stream);                    CurrentStackTrace = saveHelper.LoadStackTrace(stream);                    UtcTime = stream.ReadDateTime();                    LogMessageAttributes = new LogMessageAttributes(stream);                    Message = stream.ReadString();                    Details = stream.ReadString();                    Exception = null;                    ExceptionString = stream.ReadString();                    ManagedThreadID = -1;                    PreviousFirstChanceExceptionSequenceNumber = -1;                    break;                case 2:                    EventPublisherDetails = saveHelper.LoadEventPublisherDetails(stream);                    InitialStackMessages = saveHelper.LoadStackMessages(stream);                    InitialStackTrace = saveHelper.LoadStackTrace(stream);                    CurrentStackMessages = saveHelper.LoadStackMessages(stream);                    CurrentStackTrace = saveHelper.LoadStackTrace(stream);                    UtcTime = stream.ReadDateTime();                    LogMessageAttributes = new LogMessageAttributes(stream);                    Message = stream.ReadString();                    Details = stream.ReadString();                    Exception = null;                    ExceptionString = stream.ReadString();                    ManagedThreadID = stream.ReadInt32();                    PreviousFirstChanceExceptionSequenceNumber = -1;                    break;                case 3:                    EventPublisherDetails = saveHelper.LoadEventPublisherDetails(stream);                    InitialStackMessages = saveHelper.LoadStackMessages(stream);                    InitialStackTrace = saveHelper.LoadStackTrace(stream);                    CurrentStackMessages = saveHelper.LoadStackMessages(stream);                    CurrentStackTrace = saveHelper.LoadStackTrace(stream);                    UtcTime = stream.ReadDateTime();                    LogMessageAttributes = new LogMessageAttributes(stream);                    Message = saveHelper.LoadString(stream);                    Details = saveHelper.LoadString(stream);                    Exception = null;                    ExceptionString = saveHelper.LoadString(stream);                    ManagedThreadID = stream.ReadInt32();                    PreviousFirstChanceExceptionSequenceNumber = -1;                    break;                case 4:                    EventPublisherDetails = saveHelper.LoadEventPublisherDetails(stream);                    InitialStackMessages = saveHelper.LoadStackMessages(stream);                    InitialStackTrace = saveHelper.LoadStackTrace(stream);                    CurrentStackMessages = saveHelper.LoadStackMessages(stream);                    CurrentStackTrace = saveHelper.LoadStackTrace(stream);                    UtcTime = stream.ReadDateTime();                    LogMessageAttributes = new LogMessageAttributes(stream);                    Message = saveHelper.LoadString(stream);                    Details = saveHelper.LoadString(stream);                    Exception = null;                    ExceptionString = saveHelper.LoadString(stream);                    ManagedThreadID = stream.ReadInt32();                    PreviousFirstChanceExceptionSequenceNumber = stream.ReadInt32();                    break;                default:                    throw new VersionNotFoundException();            }        }         /// <summary>        /// Creates a log message        /// </summary>        internal LogMessage(LogEventPublisherDetails eventPublisherDetails, LogStackMessages initialStackMessages, LogStackTrace initialStackTrace, LogStackMessages currentStackMessages, LogStackTrace currentStackTrace, LogMessageAttributes flags, string message, string details, Exception exception)        {            if (eventPublisherDetails == null)                throw new ArgumentNullException(nameof(eventPublisherDetails));             if (exception != null)            {                ExceptionString = exception.ToString();            }            else            {                ExceptionString = string.Empty;            }             EventPublisherDetails = eventPublisherDetails;            InitialStackMessages = initialStackMessages ?? LogStackMessages.Empty;            InitialStackTrace = initialStackTrace ?? LogStackTrace.Empty;            CurrentStackMessages = currentStackMessages ?? LogStackMessages.Empty;            CurrentStackTrace = currentStackTrace ?? LogStackTrace.Empty;            UtcTime = DateTime.UtcNow;            LogMessageAttributes = flags;            Message = message ?? string.Empty;            Details = details ?? string.Empty;            Exception = exception;            ManagedThreadID = Thread.CurrentThread.ManagedThreadId;            PreviousFirstChanceExceptionSequenceNumber = Logger.PreviousFirstChanceExceptionSequenceNumber;        }         /// <summary>Returns a string that represents the current object.</summary>        /// <returns>A string that represents the current object.</returns>        /// <filterpriority>2</filterpriority>        public override string ToString()        {            return GetMessage();        }         /// <summary>        /// Writes the log data to the stream        /// </summary>        /// <param name="stream"></param>        /// <param name="saveHelper"></param>        internal void Save(Stream stream, LogMessageSaveHelper saveHelper = null)        {            if (saveHelper == null)                saveHelper = LogMessageSaveHelper.Create(true);             stream.Write((byte)4);            saveHelper.SaveEventPublisherDetails(stream, EventPublisherDetails);            saveHelper.SaveStackMessages(stream, InitialStackMessages);            saveHelper.SaveStackTrace(stream, InitialStackTrace);            saveHelper.SaveStackMessages(stream, CurrentStackMessages);            saveHelper.SaveStackTrace(stream, CurrentStackTrace);            stream.Write(UtcTime);            LogMessageAttributes.Save(stream);            saveHelper.SaveString(stream, Message);            saveHelper.SaveString(stream, Details);            saveHelper.SaveString(stream, ExceptionString);            stream.Write(ManagedThreadID);            stream.Write(PreviousFirstChanceExceptionSequenceNumber);        }         /// <summary>        /// Gets the details of the message.        /// </summary>        /// <returns></returns>        public string GetMessage()        {            StringBuilder sb = new StringBuilder();            sb.Append("Time: ");            sb.Append(UtcTime.ToLocalTime());            sb.Append(" - ");            sb.Append(Classification.ToString());            sb.Append(" - ");            sb.Append(Level.ToString());            sb.Append(" - ");            sb.Append(Flags.ToString());            sb.Append(" - ");            sb.Append(MessageSuppression.ToString());            sb.AppendLine();            sb.Append("Event Name: ");            sb.AppendLine(EventPublisherDetails.EventName);            if (Message.Length > 0)            {                sb.Append("Message: ");                sb.AppendLine(Message);            }            if (Details.Length > 0)            {                sb.Append("Details: ");                sb.AppendLine(Details);            }            if (ExceptionString.Length > 0)            {                sb.AppendLine("Exception: ");                sb.AppendLine(ExceptionString);            }            if (EventPublisherDetails.TypeData.TypeName.Length > 0)            {                sb.AppendLine("Message Type: " + EventPublisherDetails.TypeData.TypeName);            }            if (EventPublisherDetails.TypeData.AssemblyName.Length > 0)            {                sb.AppendLine($"Message Assembly: {EventPublisherDetails.TypeData.AssemblyName} ({EventPublisherDetails.TypeData.AssemblyVersion}) ");            }            sb.AppendLine($"Managed Thread Id: {ManagedThreadID}");              if (!ReferenceEquals(InitialStackMessages, LogStackMessages.Empty))            {                sb.AppendLine();                sb.AppendLine("Initial Stack Messages: ");                sb.AppendLine(InitialStackMessages.ToString());            }            if (!ReferenceEquals(InitialStackTrace, LogStackTrace.Empty))            {                sb.AppendLine();                sb.AppendLine("Initial Stack Trace: ");                sb.AppendLine(InitialStackTrace.ToString());            }            if (!ReferenceEquals(CurrentStackMessages, LogStackMessages.Empty))            {                sb.AppendLine();                sb.AppendLine("Current Stack Messages: ");                sb.AppendLine(CurrentStackMessages.ToString());            }            if (!ReferenceEquals(CurrentStackTrace, LogStackTrace.Empty))            {                sb.AppendLine();                sb.AppendLine("Current Stack Trace: ");                sb.AppendLine(CurrentStackTrace.ToString());            }             return sb.ToString();        }    }}