//******************************************************************************************************//  Logger.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.Collections.Generic;using System.Security;using System.Security.Permissions;using System.Threading;using GSF.Threading; namespace GSF.Diagnostics{    /// <summary>    /// Manages the collection and reporting of logging information in a system.    /// </summary>    public static class Logger    {        private enum SuppressionMode        {            None = 0,            FirstChanceExceptionOnly = 1,            AllMessages = 2,        }         private static class ThreadLocalThreadStack        {            [ThreadStatic]            private static ThreadStack s_localValue;             /// <summary>            /// Gets the <see cref="ThreadStack"/> item for the current thread.            /// Note: No exchange compare is needed since <see cref="s_localValue"/>            /// is local only to the current thread.            /// </summary>            public static ThreadStack Value => s_localValue ?? (s_localValue = new ThreadStack());        }         /// <summary>        /// This information is maintained in a ThreadLocal variable and is about         /// messages and log suppression applied at higher levels of the calling stack.        /// </summary>        private class ThreadStack        {            public int PreviousFirstChanceExceptionSequenceNumber;            private List<LogStackMessages> m_threadStackDetails = new List<LogStackMessages>();            private LogStackMessages m_stackMessageCache;            private List<SuppressionMode> m_logMessageSuppressionStack = new List<SuppressionMode>();             public bool ShouldSuppressLogMessages => m_logMessageSuppressionStack.Count > 0 && m_logMessageSuppressionStack[m_logMessageSuppressionStack.Count - 1] >= SuppressionMode.AllMessages;            public bool ShouldSuppressFirstChanceLogMessages => m_logMessageSuppressionStack.Count > 0 && m_logMessageSuppressionStack[m_logMessageSuppressionStack.Count - 1] >= SuppressionMode.FirstChanceExceptionOnly;             public LogStackMessages GetStackMessages()            {                if (m_stackMessageCache == null)                {                    if (m_threadStackDetails.Count == 0)                    {                        m_stackMessageCache = LogStackMessages.Empty;                    }                    else                    {                        m_stackMessageCache = new LogStackMessages(m_threadStackDetails);                    }                }                return m_stackMessageCache;            }             public StackDisposal AppendStackMessages(LogStackMessages messages)            {                m_stackMessageCache = null;                m_threadStackDetails.Add(messages);                 int depth = m_threadStackDetails.Count;                if (depth >= s_stackDisposalStackMessages.Length)                {                    GrowStackDisposal(depth + 1);                }                return s_stackDisposalStackMessages[depth];            }             public StackDisposal SuppressLogMessages(SuppressionMode suppressionMode)            {                m_logMessageSuppressionStack.Add(suppressionMode);                int depth = m_logMessageSuppressionStack.Count;                if (depth >= s_stackDisposalSuppressionFlags.Length)                {                    GrowStackDisposal(depth + 1);                }                return s_stackDisposalSuppressionFlags[depth];            }             public void RemoveStackMessage(int depth)            {                while (m_threadStackDetails.Count >= depth)                {                    m_threadStackDetails.RemoveAt(m_threadStackDetails.Count - 1);                }                m_stackMessageCache = null;            }             public void RemoveSuppression(int depth)            {                while (m_logMessageSuppressionStack.Count >= depth)                {                    m_logMessageSuppressionStack.RemoveAt(m_logMessageSuppressionStack.Count - 1);                }            }        }         private static LoggerInternal s_logger;         /// <summary>        /// The default console based log subscriber.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public static readonly LogSubscriptionConsole Console;        /// <summary>        /// The default file based log writer.        /// </summary>        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes")]        public static readonly LogSubscriptionFileWriter FileWriter;         private static readonly LogPublisher Log;        private static readonly LogEventPublisher EventFirstChanceException;        private static readonly LogEventPublisher EventAppDomainException;        private static readonly LogEventPublisher EventSwallowedException;        private static StackDisposal[] s_stackDisposalStackMessages;        private static StackDisposal[] s_stackDisposalSuppressionFlags;        private static readonly object SyncRoot = new object();         static Logger()        {            //Initializes the empty object of StackTraceDetails            LogStackTrace.Initialize();            LogStackMessages.Initialize();            GrowStackDisposal(1);             s_logger = new LoggerInternal(out s_logger);            Console = new LogSubscriptionConsole();            FileWriter = new LogSubscriptionFileWriter(1000);             AppDomain.CurrentDomain.FirstChanceException += CurrentDomain_FirstChanceException;            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;             Log = CreatePublisher(typeof(Logger), MessageClass.Component);            Log.InitialStackTrace = LogStackTrace.Empty;            EventFirstChanceException = Log.RegisterEvent(MessageLevel.NA, MessageFlags.SystemHealth, "First Chance App Domain Exception", 30, MessageRate.PerSecond(30), 1000);            EventAppDomainException = Log.RegisterEvent(MessageLevel.Critical, MessageFlags.SystemHealth, "Unhandled App Domain Exception");            EventSwallowedException = Log.RegisterEvent(MessageLevel.Debug, MessageFlags.None, "Exception was Swallowed", 30, MessageRate.PerSecond(30), 1000);             ShutdownHandler.Initialize();        }          /// <summary>        /// Ensures that the logger has been initialized.         /// </summary>        internal static void Initialize()        {            //Handled in the static constructor.        }         /// <summary>        /// Ensures that the logger is properly shutdown.        /// This is called from ShutdownHandler.        /// </summary>        internal static void Shutdown()        {            try            {                Log.Publish(MessageLevel.Critical, MessageFlags.SystemHealth, "Logger is shutting down.");                s_logger.Dispose();                Console.Verbose = VerboseLevel.None;                FileWriter.Dispose();                //Cannot raise log messages here since the logger is now shutdown.            }            catch (Exception)            {            }        }         /// <summary>        /// Gets the sequence number of the most recent First Chance Exception log         /// </summary>        internal static int PreviousFirstChanceExceptionSequenceNumber => ThreadLocalThreadStack.Value.PreviousFirstChanceExceptionSequenceNumber;         /// <summary>        /// Gets if Log Messages should be suppressed.        /// </summary>        public static bool ShouldSuppressLogMessages => ThreadLocalThreadStack.Value.ShouldSuppressLogMessages;         /// <summary>        /// Gets if First Chance Exception Log Messages should be suppressed.        /// </summary>        public static bool ShouldSuppressFirstChanceLogMessages => ThreadLocalThreadStack.Value.ShouldSuppressFirstChanceLogMessages;         private static void CurrentDomain_FirstChanceException(object sender, System.Runtime.ExceptionServices.FirstChanceExceptionEventArgs e)        {            if ((Thread.CurrentThread.ThreadState & (ThreadState.AbortRequested | ThreadState.Aborted)) != 0)            {                return;            }            if (ShouldSuppressFirstChanceLogMessages)                return;            using (SuppressFirstChanceExceptionLogMessages())            {                try                {                    EventFirstChanceException.Publish(null, null, e.Exception);                }                catch (Exception)                {                    //swallow any exceptions.                }                ThreadLocalThreadStack.Value.PreviousFirstChanceExceptionSequenceNumber++;            }        }         private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)        {            if ((Thread.CurrentThread.ThreadState & (ThreadState.AbortRequested | ThreadState.Aborted)) != 0)            {                return;            }            using (SuppressFirstChanceExceptionLogMessages())            {                try                {                    EventAppDomainException.Publish(null, null, e.ExceptionObject as Exception);                }                catch (Exception)                {                    //swallow any exceptions.                }            }        }         /// <summary>        /// Looks up the type of the log source        /// </summary>        /// <param name="type">the type</param>        /// <param name="classification">the classification of the type of messages that this publisher will raise.</param>        /// <returns></returns>        public static LogPublisher CreatePublisher(Type type, MessageClass classification)        {            return new LogPublisher(s_logger, s_logger.CreateType(type), classification);        }         /// <summary>        /// Creates a <see cref="LogSubscriber"/>        /// </summary>        /// <returns></returns>        public static LogSubscriber CreateSubscriber(VerboseLevel level = VerboseLevel.None)        {            var subscriber = new LogSubscriber(s_logger.CreateSubscriber());            subscriber.SubscribeToAll(level);            return subscriber;        }         /// <summary>        /// Logs that a first chance exception was intentionally not handled for the provided reason.        /// In the LogFileViewer it will filter messages differently if it was indicated that they were swallowed.        /// </summary>        /// <param name="ex">the exception that was swallowed</param>        /// <param name="message">message to include, such as a reason why it was swallowed.</param>        /// <param name="details">additional details.</param>        /// <param name="additionalFlags">additional flags that can be set with this swallowed exception.</param>        public static void SwallowException(Exception ex, string message = null, string details = null, MessageFlags additionalFlags = MessageFlags.None)        {            EventSwallowedException.Publish(additionalFlags, message, details, ex);            //Increment this value to ensure that nothing else matches with the exception since it has been removed.            ThreadLocalThreadStack.Value.PreviousFirstChanceExceptionSequenceNumber++;        }         /// <summary>        /// Searches the current stack frame for all related messages that will be published with this message.        /// </summary>        /// <returns></returns>        public static LogStackMessages GetStackMessages()        {            return ThreadLocalThreadStack.Value.GetStackMessages();        }         /// <summary>        /// Temporarily appends data to the thread's stack so the data can be propagated to any messages generated on this thread.        /// Be sure to call Dispose on the returned object to remove this from the stack.        /// </summary>        /// <param name="messages"></param>        /// <returns></returns>        public static IDisposable AppendStackMessages(LogStackMessages messages)        {            return ThreadLocalThreadStack.Value.AppendStackMessages(messages);        }         /// <summary>        /// Sets a flag that will prevent log messages from being raised on this thread.        /// Remember to dispose of the callback to remove this suppression.        /// </summary>        /// <returns></returns>        public static IDisposable SuppressLogMessages()        {            return ThreadLocalThreadStack.Value.SuppressLogMessages(SuppressionMode.AllMessages);        }         /// <summary>        /// Sets a flag that will prevent First Chance Exception log messages from being raised on this thread.        /// Remember to dispose of the callback to remove this suppression.        /// </summary>        /// <returns></returns>        public static IDisposable SuppressFirstChanceExceptionLogMessages()        {            return ThreadLocalThreadStack.Value.SuppressLogMessages(SuppressionMode.FirstChanceExceptionOnly);        }         /// <summary>        /// Sets a flag that will allow log messages to be raised again.        /// Remember to dispose of the callback to remove this override.        /// </summary>        /// <returns></returns>        public static IDisposable OverrideSuppressLogMessages()        {            return ThreadLocalThreadStack.Value.SuppressLogMessages(SuppressionMode.None);        }         /// <summary>        /// Temporarily appends data to the thread's stack so the data can be propagated to any messages generated on this thread.        /// Be sure to call Dispose on the returned object to remove this from the stack.        /// </summary>        /// <returns></returns>        public static IDisposable AppendStackMessages(string key, string value)        {            return AppendStackMessages(new LogStackMessages(key, value));        }         private static void GrowStackDisposal(int desiredSize)        {            //Since these depths are relatively small, growing them both together has minor consequence.            lock (SyncRoot)            {                while (s_stackDisposalStackMessages == null || s_stackDisposalStackMessages.Length < desiredSize)                {                    //Note: both are grown together and completely reinitialized to improve                     //      locality of reference.                    int lastSize = s_stackDisposalStackMessages?.Length ?? 2;                    StackDisposal[] stackMessages = new StackDisposal[lastSize * 2];                    for (int x = 0; x < stackMessages.Length; x++)                    {                        stackMessages[x] = new StackDisposal(x, DisposeStackMessage);                    }                    StackDisposal[] suppressionFlags = new StackDisposal[lastSize * 2];                    for (int x = 0; x < suppressionFlags.Length; x++)                    {                        suppressionFlags[x] = new StackDisposal(x, DisposeSuppressionFlags);                    }                    s_stackDisposalStackMessages = stackMessages;                    s_stackDisposalSuppressionFlags = suppressionFlags;                }            }        }         private static void DisposeStackMessage(int depth)        {            ThreadLocalThreadStack.Value.RemoveStackMessage(depth);        }        private static void DisposeSuppressionFlags(int depth)        {            ThreadLocalThreadStack.Value.RemoveSuppression(depth);        }         /// <summary>        /// A class that will undo a temporary change in the stack variables. Note, this class         /// will be reused. Therefore setting some kind of disposed flag will cause make this         /// class unusable. The side effect of multiple calls to Dispose is tolerable.        /// </summary>        private class StackDisposal : IDisposable        {            private readonly int m_depth;            private readonly Action<int> m_callback;             internal StackDisposal(int depth, Action<int> callback)            {                m_depth = depth;                m_callback = callback;            }             /// <summary>            /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.            /// </summary>            /// <filterpriority>2</filterpriority>            public void Dispose()            {                m_callback(m_depth);            }        }    }   }