GoalBook - A Hybrid Smart Client

//===============================================================================
// Goal Book.
// Copyright � 2009 Mark Brownsword. 
//===============================================================================

#region Using Statements
using System;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using GoalBook.Infrastructure.Interfaces;
using Microsoft.Practices.Composite.Logging;
#endregion

namespace GoalBook.Shell.Services
{
    /// <summary>
    /// Class for logging system exceptions and other information to the system event log.
    /// </summary>
    public class EventLogging : ILoggerFacade, ILoggerService
    {
        #region Constants and Enums
        private Priority _priority = Priority.None;
        private readonly string LOG = "Application";
        private readonly string EVENT_SOURCE = AssemblyInfo.GetCustomAttribute<AssemblyProductAttribute>().Product;
        #endregion

        #region Inner Classes and Structures
        #endregion

        #region Delegates and Events
        #endregion

        #region Instance and Shared Fields
        #endregion

        #region Constructors
        /// <summary>
        /// Constructor.
        /// </summary>
        public EventLogging(Priority priority)
        {
            _priority = priority;
        }
        #endregion

        #region Properties 
        /// <summary>
        /// Reference to LoggingLevel.
        /// </summary>
        public Priority LoggingLevel
        {
            get { return _priority; }
            set { _priority = value; }
        }
        #endregion

        #region Private and Protected Methods
        /// <summary>
        /// Write the specified message to the local event log.
        /// </summary>        
        private void WriteEventLogEntry(string Message, EventLogEntryType EventType)
        {
            EventLog EventLogger = new EventLog();
            
            if (CheckEventSourceExists(true))
            {
                EventLogger.Log = LOG;
                EventLogger.Source = EVENT_SOURCE;

                try
                {
                    EventLogger.WriteEntry(Message, EventType);
                }
                catch (Exception EventLoggerException)
                {
                    throw new ApplicationException("Error writing to event log", EventLoggerException);
                }
            }            
        }
        /// <summary>
        /// Create specified event source (requires administrator permission to 
        /// write a registry setting). TODO: Add declarative permission check?
        /// </summary>        
        private bool CreateEventSource()
        {
            if (!EventLog.SourceExists(EVENT_SOURCE))
            {
                try
                {
                    EventLog.CreateEventSource(EVENT_SOURCE, LOG);
                    WriteEventLogEntry(string.Format("Event source setup for {0}.", EVENT_SOURCE), EventLogEntryType.Information);                    
                }
                catch (Exception) { return false; }
            }
            return true;
        }
        #endregion

        #region Public Methods
        /// <summary>
        /// Check specified event source exists.
        /// </summary>        
        public bool CheckEventSourceExists(bool createIfNotExists)
        {
            if (!EventLog.SourceExists(EVENT_SOURCE))
            {
                if (createIfNotExists) { return CreateEventSource(); }
                else { return false; }
            }
            return true;
        }        
        #endregion

        #region Event Handlers
        #endregion

        #region Base Class Overrides
        #endregion

        #region Interface Members
        /// <summary>
        /// Implementation for ILoggerFacade Log method.
        /// </summary>        
        public void Log(string message, Category category, Priority priority)
        {
            if (priority > _priority) { return; }

            switch (category)
            {                                   
                case Category.Exception:
                    WriteEventLogEntry(message, EventLogEntryType.Error);
                    break;
                case Category.Debug:
                case Category.Info:
                    WriteEventLogEntry(message, EventLogEntryType.Information);
                    break;
                case Category.Warn:
                    WriteEventLogEntry(message, EventLogEntryType.Warning);
                    break;                
            }
        }
        /// <summary>
        /// Get Exception Message Implementation for ILoggerService GetExceptionMessage 
        /// method. Includes inner exceptions and stack trace.
        /// </summary>        
        public string GetExceptionMessage(Exception ex)
        {
            Exception exception = ex;
            string topException = exception.Message;
            string innerException = string.Empty;
            string stackTrace = (exception.StackTrace == null ? Environment.StackTrace : exception.StackTrace.ToString());
            StringBuilder message = new StringBuilder();

            while (exception.InnerException != null)
            {
                exception = exception.InnerException;
                innerException += string.Format("{0}{2}{1}{2}{2}", exception.Message, exception.StackTrace, Environment.NewLine);
            }

            message.AppendFormat("Exception Message: {0}{1}", topException, Environment.NewLine);
            message.AppendFormat("Inner Exceptions: {0}{1}{1}", innerException, Environment.NewLine);
            message.AppendFormat("Stack Trace: {0}", stackTrace);

            return message.ToString();
        }
        #endregion
    }
}