feat: move PD Core into Essentials

src/PepperDash.Core/Logging/CrestronEnricher.cs

@@ -0,0 +1,37 @@
+using Crestron.SimplSharp;
+using Serilog.Core;
+using Serilog.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Core.Logging
+{
+    public class CrestronEnricher : ILogEventEnricher
+    {
+        static readonly string _appName;
+
+        static CrestronEnricher()
+        {
+            switch (CrestronEnvironment.DevicePlatform)
+            {
+                case eDevicePlatform.Appliance:
+                    _appName = $"App {InitialParametersClass.ApplicationNumber}";
+                    break;
+                case eDevicePlatform.Server:
+                    _appName = $"{InitialParametersClass.RoomId}";
+                    break;
+            }
+        }
+            
+
+        public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
+        {
+            var property = propertyFactory.CreateProperty("App", _appName);
+
+            logEvent.AddOrUpdateProperty(property);
+        }
+    }
+}

src/PepperDash.Core/Logging/Debug.cs

@@ -0,0 +1,895 @@
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.CrestronDataStore;
+using Crestron.SimplSharp.CrestronIO;
+using Crestron.SimplSharp.CrestronLogger;
+using Newtonsoft.Json;
+using PepperDash.Core.Logging;
+using Serilog;
+using Serilog.Context;
+using Serilog.Core;
+using Serilog.Events;
+using Serilog.Formatting.Compact;
+using Serilog.Formatting.Json;
+using Serilog.Templates;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace PepperDash.Core
+{
+    /// <summary>
+    /// Contains debug commands for use in various situations
+    /// </summary>
+    public static class Debug
+    {
+        private static readonly string LevelStoreKey = "ConsoleDebugLevel";
+        private static readonly string WebSocketLevelStoreKey = "WebsocketDebugLevel";
+        private static readonly string ErrorLogLevelStoreKey = "ErrorLogDebugLevel";
+        private static readonly string FileLevelStoreKey = "FileDebugLevel";
+
+        private static readonly Dictionary<uint, LogEventLevel> _logLevels = new Dictionary<uint, LogEventLevel>()
+        {
+            {0, LogEventLevel.Information },
+            {3, LogEventLevel.Warning },
+            {4, LogEventLevel.Error },
+            {5, LogEventLevel.Fatal },
+            {1, LogEventLevel.Debug },
+            {2, LogEventLevel.Verbose },
+        };
+
+        private static ILogger _logger;
+
+        private static readonly LoggingLevelSwitch _consoleLoggingLevelSwitch;
+
+        private static readonly LoggingLevelSwitch _websocketLoggingLevelSwitch;
+
+        private static readonly LoggingLevelSwitch _errorLogLevelSwitch;
+
+        private static readonly LoggingLevelSwitch _fileLevelSwitch;
+
+        public static LogEventLevel WebsocketMinimumLogLevel
+        {
+            get { return _websocketLoggingLevelSwitch.MinimumLevel; }
+        }
+
+        private static readonly DebugWebsocketSink _websocketSink;
+
+        public static DebugWebsocketSink WebsocketSink
+        {
+            get { return _websocketSink; }
+        }
+
+        /// <summary>
+        /// Describes the folder location where a given program stores it's debug level memory. By default, the
+        /// file written will be named appNdebug where N is 1-10.
+        /// </summary>
+        public static string OldFilePathPrefix = @"\nvram\debug\";
+
+        /// <summary>
+        /// Describes the new folder location where a given program stores it's debug level memory. By default, the
+        /// file written will be named appNdebug where N is 1-10.
+        /// </summary>
+        public static string NewFilePathPrefix = @"\user\debug\";
+
+        /// <summary>
+        /// The name of the file containing the current debug settings.
+        /// </summary>
+        public static string FileName = string.Format(@"app{0}Debug.json", InitialParametersClass.ApplicationNumber);
+
+        /// <summary>
+        /// Debug level to set for a given program.
+        /// </summary>
+        public static int Level { get; private set; }
+
+        /// <summary>
+        /// When this is true, the configuration file will NOT be loaded until triggered by either a console command or a signal
+        /// </summary>
+        public static bool DoNotLoadConfigOnNextBoot { get; private set; }
+
+        private static DebugContextCollection _contexts;
+
+        private const int SaveTimeoutMs = 30000;
+
+        public static bool IsRunningOnAppliance = CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance;
+
+        /// <summary>
+        /// Version for the currently loaded PepperDashCore dll
+        /// </summary>
+        public static string PepperDashCoreVersion { get; private set; } 
+
+        private static CTimer _saveTimer;
+
+		/// <summary>
+		/// When true, the IncludedExcludedKeys dict will contain keys to include. 
+		/// When false (default), IncludedExcludedKeys will contain keys to exclude.
+		/// </summary>
+		private static bool _excludeAllMode;
+
+		//static bool ExcludeNoKeyMessages;
+
+		private static readonly Dictionary<string, object> IncludedExcludedKeys;
+
+        private static readonly LoggerConfiguration _defaultLoggerConfiguration;
+
+        private static LoggerConfiguration _loggerConfiguration;
+
+        public static LoggerConfiguration LoggerConfiguration => _loggerConfiguration;
+
+        static Debug()
+        {
+            CrestronDataStoreStatic.InitCrestronDataStore();
+
+            var defaultConsoleLevel = GetStoredLogEventLevel(LevelStoreKey);
+
+            var defaultWebsocketLevel = GetStoredLogEventLevel(WebSocketLevelStoreKey);
+
+            var defaultErrorLogLevel = GetStoredLogEventLevel(ErrorLogLevelStoreKey);
+
+            var defaultFileLogLevel = GetStoredLogEventLevel(FileLevelStoreKey);
+
+            _consoleLoggingLevelSwitch = new LoggingLevelSwitch(initialMinimumLevel: defaultConsoleLevel);            
+
+            _websocketLoggingLevelSwitch = new LoggingLevelSwitch(initialMinimumLevel: defaultWebsocketLevel);
+
+            _errorLogLevelSwitch = new LoggingLevelSwitch(initialMinimumLevel: defaultErrorLogLevel);
+
+            _fileLevelSwitch = new LoggingLevelSwitch(initialMinimumLevel: defaultFileLogLevel);
+
+            _websocketSink = new DebugWebsocketSink(new JsonFormatter(renderMessage: true));
+
+            var logFilePath = CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance ?
+                $@"{Directory.GetApplicationRootDirectory()}{Path.DirectorySeparatorChar}user{Path.DirectorySeparatorChar}debug{Path.DirectorySeparatorChar}app{InitialParametersClass.ApplicationNumber}{Path.DirectorySeparatorChar}global-log.log" :
+                $@"{Directory.GetApplicationRootDirectory()}{Path.DirectorySeparatorChar}user{Path.DirectorySeparatorChar}debug{Path.DirectorySeparatorChar}room{InitialParametersClass.RoomId}{Path.DirectorySeparatorChar}global-log.log";
+
+            CrestronConsole.PrintLine($"Saving log files to {logFilePath}");
+
+            var errorLogTemplate = CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance 
+                ? "{@t:fff}ms [{@l:u4}]{#if Key is not null}[{Key}]{#end} {@m}{#if @x is not null}\r\n{@x}{#end}"
+                : "[{@t:yyyy-MM-dd HH:mm:ss.fff}][{@l:u4}][{App}]{#if Key is not null}[{Key}]{#end} {@m}{#if @x is not null}\r\n{@x}{#end}";
+
+            _defaultLoggerConfiguration = new LoggerConfiguration()
+                .MinimumLevel.Verbose()
+                .Enrich.FromLogContext()
+                .Enrich.With(new CrestronEnricher())
+                .WriteTo.Sink(new DebugConsoleSink(new ExpressionTemplate("[{@t:yyyy-MM-dd HH:mm:ss.fff}][{@l:u4}][{App}]{#if Key is not null}[{Key}]{#end} {@m}{#if @x is not null}\r\n{@x}{#end}")), levelSwitch: _consoleLoggingLevelSwitch)
+                .WriteTo.Sink(_websocketSink, levelSwitch: _websocketLoggingLevelSwitch)
+                .WriteTo.Sink(new DebugErrorLogSink(new ExpressionTemplate(errorLogTemplate)), levelSwitch: _errorLogLevelSwitch)
+                .WriteTo.File(new RenderedCompactJsonFormatter(), logFilePath,                                    
+                    rollingInterval: RollingInterval.Day,
+                    restrictedToMinimumLevel: LogEventLevel.Debug,
+                    retainedFileCountLimit: CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance ? 30 : 60,
+                    levelSwitch: _fileLevelSwitch
+                );
+
+            try
+            {
+                if (InitialParametersClass.NumberOfRemovableDrives > 0)
+                {
+                    CrestronConsole.PrintLine("{0} RM Drive(s) Present. Initializing CrestronLogger", InitialParametersClass.NumberOfRemovableDrives);
+                    _defaultLoggerConfiguration.WriteTo.Sink(new DebugCrestronLoggerSink());
+                }
+                else
+                    CrestronConsole.PrintLine("No RM Drive(s) Present. Not using Crestron Logger");
+            }
+            catch (Exception e)
+            {
+                CrestronConsole.PrintLine("Initializing of CrestronLogger failed: {0}", e);
+            }
+
+            // Instantiate the root logger
+            _loggerConfiguration = _defaultLoggerConfiguration;
+
+            _logger = _loggerConfiguration.CreateLogger();
+            // Get the assembly version and print it to console and the log
+            GetVersion();
+
+            string msg = $"[App {InitialParametersClass.ApplicationNumber}] Using PepperDash_Core v{PepperDashCoreVersion}";
+
+            if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Server)
+            {
+                msg = $"[Room {InitialParametersClass.RoomId}] Using PepperDash_Core v{PepperDashCoreVersion}";
+            }
+
+            CrestronConsole.PrintLine(msg);
+
+            LogMessage(LogEventLevel.Information,msg);
+
+			IncludedExcludedKeys = new Dictionary<string, object>();
+            
+            if (CrestronEnvironment.RuntimeEnvironment == eRuntimeEnvironment.SimplSharpPro)
+            {
+                // Add command to console
+                CrestronConsole.AddNewConsoleCommand(SetDoNotLoadOnNextBootFromConsole, "donotloadonnextboot", 
+                    "donotloadonnextboot:P [true/false]: Should the application load on next boot", ConsoleAccessLevelEnum.AccessOperator);
+
+                CrestronConsole.AddNewConsoleCommand(SetDebugFromConsole, "appdebug",
+                    "appdebug:P [0-5]: Sets the application's console debug message level",
+                    ConsoleAccessLevelEnum.AccessOperator);
+                CrestronConsole.AddNewConsoleCommand(ShowDebugLog, "appdebuglog",
+                    "appdebuglog:P [all] Use \"all\" for full log.", 
+                    ConsoleAccessLevelEnum.AccessOperator);
+                CrestronConsole.AddNewConsoleCommand(s => CrestronLogger.Clear(false), "appdebugclear",
+                    "appdebugclear:P Clears the current custom log", 
+                    ConsoleAccessLevelEnum.AccessOperator);
+				CrestronConsole.AddNewConsoleCommand(SetDebugFilterFromConsole, "appdebugfilter",
+					"appdebugfilter [params]", ConsoleAccessLevelEnum.AccessOperator);
+            }
+
+            CrestronEnvironment.ProgramStatusEventHandler += CrestronEnvironment_ProgramStatusEventHandler;
+
+            LoadMemory();
+
+            var context = _contexts.GetOrCreateItem("DEFAULT");
+            Level = context.Level;
+            DoNotLoadConfigOnNextBoot = context.DoNotLoadOnNextBoot;
+
+            if(DoNotLoadConfigOnNextBoot)
+                CrestronConsole.PrintLine(string.Format("Program {0} will not load config after next boot.  Use console command go:{0} to load the config manually", InitialParametersClass.ApplicationNumber));
+
+            _consoleLoggingLevelSwitch.MinimumLevelChanged += (sender, args) =>
+            {
+                Console(0, "Console debug level set to {0}", _consoleLoggingLevelSwitch.MinimumLevel);
+            };
+        }
+
+        public static void UpdateLoggerConfiguration(LoggerConfiguration config)
+        {
+            _loggerConfiguration = config;
+
+            _logger = config.CreateLogger();
+        }
+
+        public static void ResetLoggerConfiguration()
+        {
+            _loggerConfiguration = _defaultLoggerConfiguration;
+
+            _logger = _loggerConfiguration.CreateLogger();
+        }
+
+        private static LogEventLevel GetStoredLogEventLevel(string levelStoreKey)
+        {
+            try
+            {
+                var result = CrestronDataStoreStatic.GetLocalIntValue(levelStoreKey, out int logLevel);                
+
+                if (result != CrestronDataStore.CDS_ERROR.CDS_SUCCESS)
+                {
+                    CrestronConsole.Print($"Unable to retrieve stored log level for {levelStoreKey}.\r\nError: {result}.\r\nSetting level to {LogEventLevel.Information}\r\n");
+                    return LogEventLevel.Information;
+                }
+
+                if(logLevel < 0 || logLevel > 5)
+                {
+                    CrestronConsole.PrintLine($"Stored Log level not valid for {levelStoreKey}: {logLevel}. Setting level to {LogEventLevel.Information}");
+                    return LogEventLevel.Information;
+                }
+
+                return (LogEventLevel)logLevel;
+            } catch (Exception ex)
+            {
+                CrestronConsole.PrintLine($"Exception retrieving log level for {levelStoreKey}: {ex.Message}");
+                return LogEventLevel.Information;
+            }
+        }
+
+        private static void GetVersion()
+        {
+            var assembly = Assembly.GetExecutingAssembly();
+            var ver =
+                assembly
+                    .GetCustomAttributes(typeof (AssemblyInformationalVersionAttribute), false);
+
+            if (ver != null && ver.Length > 0)
+            {
+                if (ver[0] is AssemblyInformationalVersionAttribute verAttribute)
+                {
+                    PepperDashCoreVersion = verAttribute.InformationalVersion;
+                }
+            }
+            else
+            {
+                var version = assembly.GetName().Version;
+                PepperDashCoreVersion = version.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Used to save memory when shutting down
+        /// </summary>
+        /// <param name="programEventType"></param>
+        static void CrestronEnvironment_ProgramStatusEventHandler(eProgramStatusEventType programEventType)
+        {
+
+            if (programEventType == eProgramStatusEventType.Stopping)
+            {
+                Log.CloseAndFlush();
+
+                if (_saveTimer != null)
+                {
+                    _saveTimer.Stop();
+                    _saveTimer = null;
+                }
+                Console(0, "Saving debug settings");
+                SaveMemory();
+            }
+        }
+
+        /// <summary>
+        /// Callback for console command
+        /// </summary>
+        /// <param name="levelString"></param>
+        public static void SetDebugFromConsole(string levelString)
+        {
+            try
+            {
+                if (levelString.Trim() == "?")
+                {
+                    CrestronConsole.ConsoleCommandResponse(
+                    $@"Used to set the minimum level of debug messages to be printed to the console:
+{_logLevels[0]} = 0
+{_logLevels[1]} = 1
+{_logLevels[2]} = 2
+{_logLevels[3]} = 3
+{_logLevels[4]} = 4
+{_logLevels[5]} = 5");
+                    return;
+                }
+
+                if (string.IsNullOrEmpty(levelString.Trim()))
+                {
+                    CrestronConsole.ConsoleCommandResponse("AppDebug level = {0}", _consoleLoggingLevelSwitch.MinimumLevel);
+                    return;
+                }
+
+                if(int.TryParse(levelString, out var levelInt))
+                {
+                    if(levelInt < 0 || levelInt > 5)
+                    {
+                        CrestronConsole.ConsoleCommandResponse($"Error: Unable to parse {levelString} to valid log level. If using a number, value must be between 0-5");
+                        return;
+                    }
+                    SetDebugLevel((uint) levelInt);
+                    return;
+                }
+
+                if(Enum.TryParse<LogEventLevel>(levelString, out var levelEnum))
+                {
+                    SetDebugLevel(levelEnum);
+                    return;
+                }
+
+                CrestronConsole.ConsoleCommandResponse($"Error: Unable to parse {levelString} to valid log level");
+            }          
+            catch
+            {
+                CrestronConsole.ConsoleCommandResponse("Usage: appdebug:P [0-5]");
+            }
+        }
+
+        /// <summary>
+        /// Sets the debug level
+        /// </summary>
+        /// <param name="level"> Valid values 0-5</param>
+        public static void SetDebugLevel(uint level)
+        {
+            if(!_logLevels.TryGetValue(level, out var logLevel))
+            {
+                logLevel = LogEventLevel.Information;
+
+                CrestronConsole.ConsoleCommandResponse($"{level} not valid. Setting level to {logLevel}");
+
+                SetDebugLevel(logLevel);
+            }
+
+            SetDebugLevel(logLevel);
+        }
+
+        public static void SetDebugLevel(LogEventLevel level)
+        {
+            _consoleLoggingLevelSwitch.MinimumLevel = level;
+
+            CrestronConsole.ConsoleCommandResponse("[Application {0}], Debug level set to {1}\r\n",
+                InitialParametersClass.ApplicationNumber, _consoleLoggingLevelSwitch.MinimumLevel);
+
+            CrestronConsole.ConsoleCommandResponse($"Storing level {level}:{(int) level}");
+
+            var err = CrestronDataStoreStatic.SetLocalIntValue(LevelStoreKey, (int) level);
+
+            CrestronConsole.ConsoleCommandResponse($"Store result: {err}:{(int)level}");
+
+            if (err != CrestronDataStore.CDS_ERROR.CDS_SUCCESS)
+                CrestronConsole.PrintLine($"Error saving console debug level setting: {err}");
+        }
+
+        public static void SetWebSocketMinimumDebugLevel(LogEventLevel level)
+        {
+            _websocketLoggingLevelSwitch.MinimumLevel = level;            
+
+            var err = CrestronDataStoreStatic.SetLocalUintValue(WebSocketLevelStoreKey, (uint) level);
+
+            if (err != CrestronDataStore.CDS_ERROR.CDS_SUCCESS)
+                LogMessage(LogEventLevel.Information, "Error saving websocket debug level setting: {erro}", err);
+
+            LogMessage(LogEventLevel.Information, "Websocket debug level set to {0}", _websocketLoggingLevelSwitch.MinimumLevel);
+        }
+
+        public static void SetErrorLogMinimumDebugLevel(LogEventLevel level)
+        {
+            _errorLogLevelSwitch.MinimumLevel = level;
+
+            var err = CrestronDataStoreStatic.SetLocalUintValue(ErrorLogLevelStoreKey, (uint)level);
+
+            if (err != CrestronDataStore.CDS_ERROR.CDS_SUCCESS)
+                LogMessage(LogEventLevel.Information, "Error saving Error Log debug level setting: {error}", err);
+
+            LogMessage(LogEventLevel.Information, "Error log debug level set to {0}", _websocketLoggingLevelSwitch.MinimumLevel);
+        }
+
+        public static void SetFileMinimumDebugLevel(LogEventLevel level)
+        {
+            _errorLogLevelSwitch.MinimumLevel = level;
+
+            var err = CrestronDataStoreStatic.SetLocalUintValue(ErrorLogLevelStoreKey, (uint)level);
+
+            if (err != CrestronDataStore.CDS_ERROR.CDS_SUCCESS)
+                LogMessage(LogEventLevel.Information, "Error saving File debug level setting: {error}", err);
+
+            LogMessage(LogEventLevel.Information, "File debug level set to {0}", _websocketLoggingLevelSwitch.MinimumLevel);
+        }
+
+        /// <summary>
+        /// Callback for console command
+        /// </summary>
+        /// <param name="stateString"></param>
+        public static void SetDoNotLoadOnNextBootFromConsole(string stateString)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(stateString.Trim()))
+                {
+                    CrestronConsole.ConsoleCommandResponse("DoNotLoadOnNextBoot = {0}", DoNotLoadConfigOnNextBoot);
+                    return;
+                }
+
+                SetDoNotLoadConfigOnNextBoot(bool.Parse(stateString));
+            }
+            catch
+            {
+                CrestronConsole.ConsoleCommandResponse("Usage: donotloadonnextboot:P [true/false]");
+            }
+        }
+
+        /// <summary>
+        /// Callback for console command
+        /// </summary>
+        /// <param name="items"></param>
+		public static void SetDebugFilterFromConsole(string items)
+		{
+			var str = items.Trim();
+			if (str == "?")
+			{
+				CrestronConsole.ConsoleCommandResponse("Usage:\r APPDEBUGFILTER key1 key2 key3....\r " +
+					"+all: at beginning puts filter into 'default include' mode\r" +
+					"      All keys that follow will be excluded from output.\r" +
+					"-all: at beginning puts filter into 'default exclude all' mode.\r" +
+					"      All keys that follow will be the only keys that are shown\r" +
+					"+nokey: Enables messages with no key (default)\r" +
+					"-nokey: Disables messages with no key.\r" +
+					"(nokey settings are independent of all other settings)");
+				return;
+			}
+			var keys = Regex.Split(str, @"\s*");
+			foreach (var keyToken in keys)
+			{
+				var lkey = keyToken.ToLower();
+				if (lkey == "+all")
+				{
+					IncludedExcludedKeys.Clear();
+					_excludeAllMode = false;
+				}
+				else if (lkey == "-all")
+				{
+					IncludedExcludedKeys.Clear();
+					_excludeAllMode = true;
+				}
+				//else if (lkey == "+nokey")
+				//{
+				//    ExcludeNoKeyMessages = false;
+				//}
+				//else if (lkey == "-nokey")
+				//{
+				//    ExcludeNoKeyMessages = true;
+				//}
+				else
+				{
+					string key;
+					if (lkey.StartsWith("-"))
+					{
+						key = lkey.Substring(1);
+						// if in exclude all mode, we need to remove this from the inclusions
+						if (_excludeAllMode)
+						{
+							if (IncludedExcludedKeys.ContainsKey(key))
+								IncludedExcludedKeys.Remove(key);
+						}
+						// otherwise include all mode, add to the exclusions
+						else
+						{
+							IncludedExcludedKeys[key] = new object();
+						}
+					}
+					else if (lkey.StartsWith("+"))
+					{
+						key = lkey.Substring(1);
+						// if in exclude all mode, we need to add this as inclusion
+						if (_excludeAllMode)
+						{
+
+							IncludedExcludedKeys[key] = new object();
+						}
+						// otherwise include all mode, remove this from exclusions
+						else
+						{
+							if (IncludedExcludedKeys.ContainsKey(key))
+								IncludedExcludedKeys.Remove(key);
+						}
+					}
+				}
+			}
+		}
+
+
+
+
+        /// <summary>
+        /// sets the settings for a device or creates a new entry
+        /// </summary>
+        /// <param name="deviceKey"></param>
+        /// <param name="settings"></param>
+        /// <returns></returns>
+        public static void SetDeviceDebugSettings(string deviceKey, object settings)
+        {
+            _contexts.SetDebugSettingsForKey(deviceKey, settings);
+            SaveMemoryOnTimeout();
+        }
+
+        /// <summary>
+        /// Gets the device settings for a device by key or returns null
+        /// </summary>
+        /// <param name="deviceKey"></param>
+        /// <returns></returns>
+        public static object GetDeviceDebugSettingsForKey(string deviceKey)
+        {
+            return _contexts.GetDebugSettingsForKey(deviceKey);
+        }  
+
+        /// <summary>
+        /// Sets the flag to prevent application starting on next boot
+        /// </summary>
+        /// <param name="state"></param>
+        public static void SetDoNotLoadConfigOnNextBoot(bool state)
+        {
+            DoNotLoadConfigOnNextBoot = state;
+            _contexts.GetOrCreateItem("DEFAULT").DoNotLoadOnNextBoot = state;
+            SaveMemoryOnTimeout();
+
+            CrestronConsole.ConsoleCommandResponse("[Application {0}], Do Not Load Config on Next Boot set to {1}",
+                InitialParametersClass.ApplicationNumber, DoNotLoadConfigOnNextBoot);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public static void ShowDebugLog(string s)
+        {
+            var loglist = CrestronLogger.PrintTheLog(s.ToLower() == "all");
+            foreach (var l in loglist)
+                CrestronConsole.ConsoleCommandResponse(l + CrestronEnvironment.NewLine);
+        }
+
+        /// <summary>
+        /// Log an Exception using Serilog's default Exception logging mechanism
+        /// </summary>
+        /// <param name="ex">Exception to log</param>
+        /// <param name="message">Message template</param>
+        /// <param name="device">Optional IKeyed device. If provided, the Key of the device will be added to the log message</param>
+        /// <param name="args">Args to put into message template</param>
+        public static void LogMessage(Exception ex, string message, IKeyed device = null, params object[] args)
+        {
+            using (LogContext.PushProperty("Key", device?.Key))
+            {
+                _logger.Error(ex, message, args);
+            }
+        }
+
+        /// <summary>
+        /// Log a message
+        /// </summary>
+        /// <param name="level">Level to log at</param>
+        /// <param name="message">Message template</param>
+        /// <param name="device">Optional IKeyed device. If provided, the Key of the device will be added to the log message</param>
+        /// <param name="args">Args to put into message template</param>
+        public static void LogMessage(LogEventLevel level, string message, IKeyed device=null, params object[] args)
+        {
+            using (LogContext.PushProperty("Key", device?.Key))
+            {
+                _logger.Write(level, message, args);
+            }
+        }
+
+        public static void LogMessage(LogEventLevel level, string message, params object[] args)
+        {
+            LogMessage(level, message, null, args);
+        }
+
+        public static void LogMessage(LogEventLevel level, IKeyed keyed, string message, params object[] args)
+        {
+            LogMessage(level, message, keyed, args);
+        }
+
+
+        private static void LogMessage(uint level, string format, params object[] items)
+        {
+            if (!_logLevels.ContainsKey(level)) return;
+
+            var logLevel = _logLevels[level];
+            
+            LogMessage(logLevel, format, items);
+        }
+
+        private static void LogMessage(uint level, IKeyed keyed, string format, params object[] items)
+        {
+            if (!_logLevels.ContainsKey(level)) return;
+
+            var logLevel = _logLevels[level];
+
+            LogMessage(logLevel, keyed, format, items);
+        }
+
+
+        /// <summary>
+        /// Prints message to console if current debug level is equal to or higher than the level of this message.
+        /// Uses CrestronConsole.PrintLine.
+        /// </summary>
+        /// <param name="level"></param>
+        /// <param name="format">Console format string</param>
+        /// <param name="items">Object parameters</param>
+        [Obsolete("Use LogMessage methods")]
+        public static void Console(uint level, string format, params object[] items)
+        {
+
+            LogMessage(level, format, items);
+
+            //if (IsRunningOnAppliance)
+            //{
+            //    CrestronConsole.PrintLine("[{0}]App {1} Lvl {2}:{3}", DateTime.Now.ToString("HH:mm:ss.fff"),
+            //        InitialParametersClass.ApplicationNumber,
+            //        level,
+            //        string.Format(format, items));
+            //}
+        }
+
+        /// <summary>
+		/// Logs to Console when at-level, and all messages to error log, including device key			
+        /// </summary>
+        [Obsolete("Use LogMessage methods")]
+        public static void Console(uint level, IKeyed dev, string format, params object[] items)
+        {
+            LogMessage(level, dev, format, items);
+
+            //if (Level >= level)
+            //    Console(level, "[{0}] {1}", dev.Key, message);
+        }
+
+        /// <summary>
+        /// Prints message to console if current debug level is equal to or higher than the level of this message. Always sends message to Error Log.
+        /// Uses CrestronConsole.PrintLine.
+        /// </summary>
+        [Obsolete("Use LogMessage methods")]
+        public static void Console(uint level, IKeyed dev, ErrorLogLevel errorLogLevel,
+            string format, params object[] items)
+        {           
+            LogMessage(level, dev, format, items);
+        }
+
+        /// <summary>
+        /// Logs to Console when at-level, and all messages to error log
+        /// </summary>
+        [Obsolete("Use LogMessage methods")]
+        public static void Console(uint level, ErrorLogLevel errorLogLevel,
+            string format, params object[] items)
+        {
+            LogMessage(level, format, items);
+        }
+
+        /// <summary>
+        /// Logs to both console and the custom user log (not the built-in error log). If appdebug level is set at
+        /// or above the level provided, then the output will be written to both console and the log. Otherwise
+        /// it will only be written to the log.
+        /// </summary>
+        [Obsolete("Use LogMessage methods")]
+        public static void ConsoleWithLog(uint level, string format, params object[] items)
+        {
+            LogMessage(level, format, items);
+
+            // var str = string.Format(format, items);
+            //if (Level >= level)
+            //    CrestronConsole.PrintLine("App {0}:{1}", InitialParametersClass.ApplicationNumber, str);
+            // CrestronLogger.WriteToLog(str, level);
+        }
+
+        /// <summary>
+        /// Logs to both console and the custom user log (not the built-in error log). If appdebug level is set at
+        /// or above the level provided, then the output will be written to both console and the log. Otherwise
+        /// it will only be written to the log.
+        /// </summary>
+        [Obsolete("Use LogMessage methods")]
+        public static void ConsoleWithLog(uint level, IKeyed dev, string format, params object[] items)
+        {
+            LogMessage(level, dev, format, items);
+
+            // var str = string.Format(format, items);
+            // CrestronLogger.WriteToLog(string.Format("[{0}] {1}", dev.Key, str), level);
+        }
+
+        /// <summary>
+        /// Prints to log and error log
+        /// </summary>
+        /// <param name="errorLogLevel"></param>
+        /// <param name="str"></param>
+        [Obsolete("Use LogMessage methods")]
+        public static void LogError(ErrorLogLevel errorLogLevel, string str)
+        {
+            switch (errorLogLevel)
+            {
+                case ErrorLogLevel.Error:
+                    LogMessage(LogEventLevel.Error, str);
+                    break;
+                case ErrorLogLevel.Warning:
+                    LogMessage(LogEventLevel.Warning, str);
+                    break;
+                case ErrorLogLevel.Notice:
+                    LogMessage(LogEventLevel.Information, str);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Writes the memory object after timeout
+        /// </summary>
+        static void SaveMemoryOnTimeout()
+        {
+            Console(0, "Saving debug settings");
+            if (_saveTimer == null)
+                _saveTimer = new CTimer(o =>
+                {
+                    _saveTimer = null;
+                    SaveMemory();
+                }, SaveTimeoutMs);
+            else
+                _saveTimer.Reset(SaveTimeoutMs);
+        }
+
+        /// <summary>
+        /// Writes the memory - use SaveMemoryOnTimeout
+        /// </summary>
+        static void SaveMemory()
+        {
+            //var dir = @"\NVRAM\debug";
+            //if (!Directory.Exists(dir))
+            //    Directory.Create(dir);
+
+            var fileName = GetMemoryFileName();
+
+            Console(0, ErrorLogLevel.Notice, "Loading debug settings file from {0}", fileName);
+
+            using (var sw = new StreamWriter(fileName))
+            {
+                var json = JsonConvert.SerializeObject(_contexts);
+                sw.Write(json);
+                sw.Flush();
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        static void LoadMemory()
+        {
+            var file = GetMemoryFileName();
+            if (File.Exists(file))
+            {
+                using (var sr = new StreamReader(file))
+                {
+                    var json = sr.ReadToEnd();
+                    _contexts = JsonConvert.DeserializeObject<DebugContextCollection>(json);
+
+                    if (_contexts != null)
+                    {
+                        Console(1, "Debug memory restored from file");
+                        return;
+                    }
+                }
+            }
+
+            _contexts = new DebugContextCollection();
+        }
+
+        /// <summary>
+        /// Helper to get the file path for this app's debug memory
+        /// </summary>
+        static string GetMemoryFileName()
+        {
+            if (CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance)
+            {
+                // CheckForMigration();
+                return string.Format(@"\user\debugSettings\program{0}", InitialParametersClass.ApplicationNumber);
+            }
+
+            return string.Format("{0}{1}user{1}debugSettings{1}{2}.json",Directory.GetApplicationRootDirectory(), Path.DirectorySeparatorChar, InitialParametersClass.RoomId);
+        }
+
+        private static void CheckForMigration()
+        {
+            var oldFilePath = String.Format(@"\nvram\debugSettings\program{0}", InitialParametersClass.ApplicationNumber);
+            var newFilePath = String.Format(@"\user\debugSettings\program{0}", InitialParametersClass.ApplicationNumber);
+
+            //check for file at old path
+            if (!File.Exists(oldFilePath))
+            {
+                Console(0, ErrorLogLevel.Notice,
+                    String.Format(
+                        @"Debug settings file migration not necessary. Using file at \user\debugSettings\program{0}",
+                        InitialParametersClass.ApplicationNumber));
+
+                return;
+            }
+
+            //create the new directory if it doesn't already exist
+            if (!Directory.Exists(@"\user\debugSettings"))
+            {
+                Directory.CreateDirectory(@"\user\debugSettings");
+            }
+
+            Console(0, ErrorLogLevel.Notice,
+                String.Format(
+                    @"File found at \nvram\debugSettings\program{0}. Migrating to \user\debugSettings\program{0}", InitialParametersClass.ApplicationNumber));
+
+            //Copy file from old path to new path, then delete it. This will overwrite the existing file
+            File.Copy(oldFilePath, newFilePath, true);
+            File.Delete(oldFilePath);
+
+            //Check if the old directory is empty, then delete it if it is
+            if (Directory.GetFiles(@"\nvram\debugSettings").Length > 0)
+            {
+                return;
+            }
+
+            Directory.Delete(@"\nvram\debugSettings");
+        }
+
+        /// <summary>
+        /// Error level to for message to be logged at
+        /// </summary>
+        public enum ErrorLogLevel
+        {
+            /// <summary>
+            /// Error
+            /// </summary>
+            Error, 
+            /// <summary>
+            /// Warning
+            /// </summary>
+            Warning, 
+            /// <summary>
+            /// Notice
+            /// </summary>
+            Notice, 
+            /// <summary>
+            /// None
+            /// </summary>
+            None,
+        }
+    }
+}

src/PepperDash.Core/Logging/DebugConsoleSink.cs

@@ -0,0 +1,55 @@
+using Crestron.SimplSharp;
+using Serilog.Configuration;
+using Serilog;
+using Serilog.Core;
+using Serilog.Events;
+using Serilog.Formatting;
+using Serilog.Formatting.Json;
+using System.IO;
+using System.Text;
+
+
+namespace PepperDash.Core
+{
+    public class DebugConsoleSink : ILogEventSink
+    {
+        private readonly ITextFormatter _textFormatter;
+
+        public void Emit(LogEvent logEvent)
+        {
+            if (!Debug.IsRunningOnAppliance) return;            
+
+            /*string message = $"[{logEvent.Timestamp}][{logEvent.Level}][App {InitialParametersClass.ApplicationNumber}]{logEvent.RenderMessage()}";
+
+            if(logEvent.Properties.TryGetValue("Key",out var value) && value is ScalarValue sv && sv.Value is string rawValue)
+            {
+                message = $"[{logEvent.Timestamp}][{logEvent.Level}][App {InitialParametersClass.ApplicationNumber}][{rawValue,3}]: {logEvent.RenderMessage()}";
+            }*/
+
+            var buffer = new StringWriter(new StringBuilder(256));
+
+            _textFormatter.Format(logEvent, buffer);
+
+            var message = buffer.ToString();
+
+            CrestronConsole.PrintLine(message);
+        }
+
+        public DebugConsoleSink(ITextFormatter formatProvider )
+        {
+            _textFormatter = formatProvider ?? new JsonFormatter();
+        }
+
+    }
+
+    public static class DebugConsoleSinkExtensions
+    {
+        public static LoggerConfiguration DebugConsoleSink(
+                             this LoggerSinkConfiguration loggerConfiguration,
+                                              ITextFormatter formatProvider = null)
+        {
+            return loggerConfiguration.Sink(new DebugConsoleSink(formatProvider));
+        }
+    }
+
+}

src/PepperDash.Core/Logging/DebugContext.cs

@@ -0,0 +1,281 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.CrestronIO;
+using Newtonsoft.Json;
+
+
+namespace PepperDash.Core
+{
+    /// <summary>
+    /// Represents a debugging context
+    /// </summary>
+    public class DebugContext
+    {
+        /// <summary>
+        /// Describes the folder location where a given program stores it's debug level memory. By default, the
+        /// file written will be named appNdebug where N is 1-10.
+        /// </summary>
+        public string Key { get; private set; }
+
+        ///// <summary>
+        ///// The name of the file containing the current debug settings.
+        ///// </summary>
+        //string FileName = string.Format(@"\nvram\debug\app{0}Debug.json", InitialParametersClass.ApplicationNumber);
+
+        DebugContextSaveData SaveData;
+
+        int SaveTimeoutMs = 30000;
+
+        CTimer SaveTimer;
+
+
+        static List<DebugContext> Contexts = new List<DebugContext>();
+
+        /// <summary>
+        /// Creates or gets a debug context
+        /// </summary>
+        /// <param name="key"></param>
+        /// <returns></returns>
+        public static DebugContext GetDebugContext(string key)
+        {
+            var context = Contexts.FirstOrDefault(c => c.Key.Equals(key, StringComparison.OrdinalIgnoreCase));
+            if (context == null)
+            {
+                context = new DebugContext(key);
+                Contexts.Add(context);
+            }
+            return context;
+        }
+
+        /// <summary>
+        /// Do not use.  For S+ access.
+        /// </summary>
+        public DebugContext() { }
+
+        DebugContext(string key)
+        {
+            Key = key;
+            if (CrestronEnvironment.RuntimeEnvironment == eRuntimeEnvironment.SimplSharpPro)
+            {
+                // Add command to console
+                CrestronConsole.AddNewConsoleCommand(SetDebugFromConsole, "appdebug",
+                    "appdebug:P [0-2]: Sets the application's console debug message level",
+                    ConsoleAccessLevelEnum.AccessOperator);
+            }
+
+            CrestronEnvironment.ProgramStatusEventHandler += CrestronEnvironment_ProgramStatusEventHandler;
+
+            LoadMemory();
+        }
+
+        /// <summary>
+        /// Used to save memory when shutting down
+        /// </summary>
+        /// <param name="programEventType"></param>
+        void CrestronEnvironment_ProgramStatusEventHandler(eProgramStatusEventType programEventType)
+        {
+            if (programEventType == eProgramStatusEventType.Stopping)
+            {
+                if (SaveTimer != null)
+                {
+                    SaveTimer.Stop();
+                    SaveTimer = null;
+                }
+                Console(0, "Saving debug settings");
+                SaveMemory();
+            }
+        }
+
+        /// <summary>
+        /// Callback for console command
+        /// </summary>
+        /// <param name="levelString"></param>
+        public void SetDebugFromConsole(string levelString)
+        {
+            try
+            {
+                if (string.IsNullOrEmpty(levelString.Trim()))
+                {
+                    CrestronConsole.ConsoleCommandResponse("AppDebug level = {0}", SaveData.Level);
+                    return;
+                }
+
+                SetDebugLevel(Convert.ToInt32(levelString));
+            }
+            catch
+            {
+                CrestronConsole.PrintLine("Usage: appdebug:P [0-2]");
+            }
+        }
+
+        /// <summary>
+        /// Sets the debug level
+        /// </summary>
+        /// <param name="level"> Valid values 0 (no debug), 1 (critical), 2 (all messages)</param>
+        public void SetDebugLevel(int level)
+        {
+            if (level <= 2)
+            {
+                SaveData.Level = level;
+                SaveMemoryOnTimeout();
+
+                CrestronConsole.PrintLine("[Application {0}], Debug level set to {1}",
+                    InitialParametersClass.ApplicationNumber, SaveData.Level);
+            }
+        }
+
+        /// <summary>
+        /// Prints message to console if current debug level is equal to or higher than the level of this message.
+        /// Uses CrestronConsole.PrintLine.
+        /// </summary>
+        /// <param name="level"></param>
+        /// <param name="format">Console format string</param>
+        /// <param name="items">Object parameters</param>
+        public void Console(uint level, string format, params object[] items)
+        {
+            if (SaveData.Level >= level)
+                CrestronConsole.PrintLine("App {0}:{1}", InitialParametersClass.ApplicationNumber,
+                    string.Format(format, items));
+        }
+
+        /// <summary>
+        /// Appends a device Key to the beginning of a message
+        /// </summary>
+        public void Console(uint level, IKeyed dev, string format, params object[] items)
+        {
+            if (SaveData.Level >= level)
+                Console(level, "[{0}] {1}", dev.Key, string.Format(format, items));
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="level"></param>
+        /// <param name="dev"></param>
+        /// <param name="errorLogLevel"></param>
+        /// <param name="format"></param>
+        /// <param name="items"></param>
+        public void Console(uint level, IKeyed dev, Debug.ErrorLogLevel errorLogLevel,
+            string format, params object[] items)
+        {
+            if (SaveData.Level >= level)
+            {
+                var str = string.Format("[{0}] {1}", dev.Key, string.Format(format, items));
+                Console(level, str);
+                LogError(errorLogLevel, str);
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="level"></param>
+        /// <param name="errorLogLevel"></param>
+        /// <param name="format"></param>
+        /// <param name="items"></param>
+        public void Console(uint level, Debug.ErrorLogLevel errorLogLevel,
+            string format, params object[] items)
+        {
+            if (SaveData.Level >= level)
+            {
+                var str = string.Format(format, items);
+                Console(level, str);
+                LogError(errorLogLevel, str);
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="errorLogLevel"></param>
+        /// <param name="str"></param>
+        public void LogError(Debug.ErrorLogLevel errorLogLevel, string str)
+        {
+            string msg = string.Format("App {0}:{1}", InitialParametersClass.ApplicationNumber, str);
+            switch (errorLogLevel)
+            {
+                case Debug.ErrorLogLevel.Error:
+                    ErrorLog.Error(msg);
+                    break;
+                case Debug.ErrorLogLevel.Warning:
+                    ErrorLog.Warn(msg);
+                    break;
+                case Debug.ErrorLogLevel.Notice:
+                    ErrorLog.Notice(msg);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Writes the memory object after timeout
+        /// </summary>
+        void SaveMemoryOnTimeout()
+        {
+            if (SaveTimer == null)
+                SaveTimer = new CTimer(o =>
+                {
+                    SaveTimer = null;
+                    SaveMemory();
+                }, SaveTimeoutMs);
+            else
+                SaveTimer.Reset(SaveTimeoutMs);
+        }
+
+        /// <summary>
+        /// Writes the memory - use SaveMemoryOnTimeout
+        /// </summary>
+        void SaveMemory()
+        {
+            using (StreamWriter sw = new StreamWriter(GetMemoryFileName()))
+            {
+                var json = JsonConvert.SerializeObject(SaveData);
+                sw.Write(json);
+                sw.Flush();
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        void LoadMemory()
+        {
+            var file = GetMemoryFileName();
+            if (File.Exists(file))
+            {
+                using (StreamReader sr = new StreamReader(file))
+                {
+                    var data = JsonConvert.DeserializeObject<DebugContextSaveData>(sr.ReadToEnd());
+                    if (data != null)
+                    {
+                        SaveData = data;
+                        Debug.Console(1, "Debug memory restored from file");
+                        return;
+                    }
+                    else
+                        SaveData = new DebugContextSaveData();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Helper to get the file path for this app's debug memory
+        /// </summary>
+        string GetMemoryFileName()
+        {
+            return string.Format(@"\NVRAM\debugSettings\program{0}-{1}", InitialParametersClass.ApplicationNumber, Key);
+        }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class DebugContextSaveData
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        public int Level { get; set; }
+    }
+}

src/PepperDash.Core/Logging/DebugCrestronLoggerSink.cs

@@ -0,0 +1,29 @@
+using Crestron.SimplSharp;
+using Crestron.SimplSharp.CrestronLogger;
+using Serilog.Core;
+using Serilog.Events;
+
+namespace PepperDash.Core.Logging
+{
+    public class DebugCrestronLoggerSink : ILogEventSink
+    {
+        public void Emit(LogEvent logEvent)
+        {
+            if (!Debug.IsRunningOnAppliance) return;
+
+            string message = $"[{logEvent.Timestamp}][{logEvent.Level}][App {InitialParametersClass.ApplicationNumber}]{logEvent.RenderMessage()}";
+
+            if (logEvent.Properties.TryGetValue("Key", out var value) && value is ScalarValue sv && sv.Value is string rawValue)
+            {
+                message = $"[{logEvent.Timestamp}][{logEvent.Level}][App {InitialParametersClass.ApplicationNumber}][{rawValue}]: {logEvent.RenderMessage()}";
+            }
+
+            CrestronLogger.WriteToLog(message, (uint)logEvent.Level);
+        }
+
+        public DebugCrestronLoggerSink()
+        {
+            CrestronLogger.Initialize(1, LoggerModeEnum.RM);
+        }
+    }
+}

src/PepperDash.Core/Logging/DebugErrorLogSink.cs

@@ -0,0 +1,65 @@
+using Crestron.SimplSharp;
+using Serilog.Core;
+using Serilog.Events;
+using Serilog.Formatting;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace PepperDash.Core.Logging
+{
+    public class DebugErrorLogSink : ILogEventSink
+    {
+        private ITextFormatter _formatter;
+
+        private Dictionary<LogEventLevel, Action<string>> _errorLogMap = new Dictionary<LogEventLevel, Action<string>>
+        {
+            { LogEventLevel.Verbose, (msg) => ErrorLog.Notice(msg) },
+            {LogEventLevel.Debug, (msg) => ErrorLog.Notice(msg) },
+            {LogEventLevel.Information, (msg) => ErrorLog.Notice(msg) },
+            {LogEventLevel.Warning, (msg) => ErrorLog.Warn(msg) },
+            {LogEventLevel.Error, (msg) => ErrorLog.Error(msg) },
+            {LogEventLevel.Fatal, (msg) => ErrorLog.Error(msg) }
+        };
+        public void Emit(LogEvent logEvent)
+        {
+            string message;
+
+            if (_formatter == null)
+            {
+                var programId = CrestronEnvironment.DevicePlatform == eDevicePlatform.Appliance
+                    ? $"App {InitialParametersClass.ApplicationNumber}"
+                    : $"Room {InitialParametersClass.RoomId}";
+
+                message = $"[{logEvent.Timestamp}][{logEvent.Level}][{programId}]{logEvent.RenderMessage()}";
+
+                if (logEvent.Properties.TryGetValue("Key", out var value) && value is ScalarValue sv && sv.Value is string rawValue)
+                {
+                    message = $"[{logEvent.Timestamp}][{logEvent.Level}][{programId}][{rawValue}]: {logEvent.RenderMessage()}";
+                }
+            } else
+            {
+                var buffer = new StringWriter(new StringBuilder(256));
+
+                _formatter.Format(logEvent, buffer);
+
+                message = buffer.ToString();
+            }
+
+            if(!_errorLogMap.TryGetValue(logEvent.Level, out var handler))
+            {
+                return;
+            }
+
+            handler(message);
+        }
+
+        public DebugErrorLogSink(ITextFormatter formatter = null)
+        {
+            _formatter = formatter;
+        }
+    }
+}

src/PepperDash.Core/Logging/DebugExtensions.cs

@@ -0,0 +1,44 @@
+using Serilog;
+using Serilog.Events;
+using System;
+using Log = PepperDash.Core.Debug;
+
+namespace PepperDash.Core.Logging
+{
+    public static class DebugExtensions
+    {
+        public static void LogException(this IKeyed device, Exception ex, string message, params object[] args)
+        {
+            Log.LogMessage(ex, message, device, args);
+        }
+        public static void LogVerbose(this IKeyed device, string message, params object[] args)
+        {
+            Log.LogMessage(LogEventLevel.Verbose, device, message, args);
+        }
+
+        public static void LogDebug(this IKeyed device, string message, params object[] args)
+        {
+            Log.LogMessage(LogEventLevel.Debug, device, message, args);
+        }
+
+        public static void LogInformation(this IKeyed device, string message, params object[] args)
+        {
+            Log.LogMessage(LogEventLevel.Information, device, message, args);
+        }
+
+        public static void LogWarning(this IKeyed device, string message, params object[] args)
+        {
+            Log.LogMessage(LogEventLevel.Warning, device, message, args);
+        }
+
+        public static void LogError(this IKeyed device, string message, params object[] args)
+        {
+            Log.LogMessage(LogEventLevel.Error, device, message, args);
+        }
+
+        public static void LogFatal(this IKeyed device, string message, params object[] args)
+        {
+            Log.LogMessage(LogEventLevel.Fatal, device, message, args);
+        }
+    }
+}

src/PepperDash.Core/Logging/DebugMemory.cs

@@ -0,0 +1,115 @@
+using System.Collections.Generic;
+using Crestron.SimplSharp;
+using Newtonsoft.Json;
+
+namespace PepperDash.Core.Logging
+{
+    /// <summary>
+    /// Class to persist current Debug settings across program restarts
+    /// </summary>
+	public class DebugContextCollection
+	{
+        /// <summary>
+        /// To prevent threading issues with the DeviceDebugSettings collection
+        /// </summary>
+        private readonly CCriticalSection _deviceDebugSettingsLock;
+
+		[JsonProperty("items")] private readonly Dictionary<string, DebugContextItem> _items;
+
+        /// <summary>
+        /// Collection of the debug settings for each device where the dictionary key is the device key
+        /// </summary>
+        [JsonProperty("deviceDebugSettings")]
+        private Dictionary<string, object> DeviceDebugSettings { get; set; }
+
+
+		/// <summary>
+		/// Default constructor
+		/// </summary>
+		public DebugContextCollection()
+		{
+            _deviceDebugSettingsLock = new CCriticalSection();
+            DeviceDebugSettings = new Dictionary<string, object>();
+			_items = new Dictionary<string, DebugContextItem>();
+		}
+
+		/// <summary>
+		/// Sets the level of a given context item, and adds that item if it does not 
+		/// exist
+		/// </summary>
+		/// <param name="contextKey"></param>
+		/// <param name="level"></param>
+		public void SetLevel(string contextKey, int level)
+		{
+			if (level < 0 || level > 2)
+				return;
+			GetOrCreateItem(contextKey).Level = level;
+		}
+
+		/// <summary>
+		/// Gets a level or creates it if not existing
+		/// </summary>
+		/// <param name="contextKey"></param>
+		/// <returns></returns>
+		public DebugContextItem GetOrCreateItem(string contextKey)
+		{
+			if (!_items.ContainsKey(contextKey))
+				_items[contextKey] = new DebugContextItem { Level = 0 };
+			return _items[contextKey];
+		}
+
+
+        /// <summary>
+        /// sets the settings for a device or creates a new entry
+        /// </summary>
+        /// <param name="deviceKey"></param>
+        /// <param name="settings"></param>
+        /// <returns></returns>
+        public void SetDebugSettingsForKey(string deviceKey, object settings)
+        {
+            try
+            {
+                _deviceDebugSettingsLock.Enter();
+
+                if (DeviceDebugSettings.ContainsKey(deviceKey))
+                {
+                    DeviceDebugSettings[deviceKey] = settings;
+                }
+                else
+                    DeviceDebugSettings.Add(deviceKey, settings);
+            }
+            finally
+            {
+                _deviceDebugSettingsLock.Leave();
+            }
+        }
+
+        /// <summary>
+        /// Gets the device settings for a device by key or returns null
+        /// </summary>
+        /// <param name="deviceKey"></param>
+        /// <returns></returns>
+        public object GetDebugSettingsForKey(string deviceKey)
+        {
+            return DeviceDebugSettings[deviceKey];
+        }
+	}
+
+	/// <summary>
+	/// Contains information about 
+	/// </summary>
+	public class DebugContextItem
+	{
+        /// <summary>
+        /// The level of debug messages to print
+        /// </summary>
+		[JsonProperty("level")]
+		public int Level { get; set; }
+
+        /// <summary>
+        /// Property to tell the program not to intitialize when it boots, if desired
+        /// </summary>
+        [JsonProperty("doNotLoadOnNextBoot")]
+        public bool DoNotLoadOnNextBoot { get; set; }
+	}
+}

src/PepperDash.Core/Logging/DebugWebsocketSink.cs

@@ -0,0 +1,271 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Serilog;
+using Serilog.Core;
+using Serilog.Events;
+using Serilog.Configuration;
+using WebSocketSharp.Server;
+using Crestron.SimplSharp;
+using WebSocketSharp;
+using System.Security.Authentication;
+using WebSocketSharp.Net;
+using X509Certificate2 = System.Security.Cryptography.X509Certificates.X509Certificate2;
+using System.IO;
+using Org.BouncyCastle.Asn1.X509;
+using Serilog.Formatting;
+using Newtonsoft.Json.Linq;
+using Serilog.Formatting.Json;
+
+namespace PepperDash.Core
+{
+    public class DebugWebsocketSink : ILogEventSink
+    {
+        private HttpServer _httpsServer;
+        
+        private string _path = "/debug/join/";
+        private const string _certificateName = "selfCres";
+        private const string _certificatePassword = "cres12345";
+
+        public int Port 
+        { get 
+            { 
+                
+                if(_httpsServer == null) return 0;
+                return _httpsServer.Port;
+            } 
+        }
+
+        public string Url
+        {
+            get
+            {
+                if (_httpsServer == null) return "";
+                return $"wss://{CrestronEthernetHelper.GetEthernetParameter(CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_IP_ADDRESS, 0)}:{_httpsServer.Port}{_httpsServer.WebSocketServices[_path].Path}";
+            }
+        }
+
+        public bool IsRunning { get => _httpsServer?.IsListening ?? false; }
+        
+
+        private readonly ITextFormatter _textFormatter;
+
+        public DebugWebsocketSink(ITextFormatter formatProvider)
+        {
+
+            _textFormatter = formatProvider ?? new JsonFormatter();
+
+            if (!File.Exists($"\\user\\{_certificateName}.pfx"))
+                CreateCert(null);
+
+            CrestronEnvironment.ProgramStatusEventHandler += type =>
+            {
+                if (type == eProgramStatusEventType.Stopping)
+                {
+                    StopServer();
+                }
+            };
+        }
+
+        private void CreateCert(string[] args)
+        {
+            try
+            {
+                //Debug.Console(0,"CreateCert Creating Utility");
+                CrestronConsole.PrintLine("CreateCert Creating Utility");
+                //var utility = new CertificateUtility();
+                var utility = new BouncyCertificate();
+                //Debug.Console(0, "CreateCert Calling CreateCert");
+                CrestronConsole.PrintLine("CreateCert Calling CreateCert");
+                //utility.CreateCert();
+                var ipAddress = CrestronEthernetHelper.GetEthernetParameter(CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_CURRENT_IP_ADDRESS, 0);
+                var hostName = CrestronEthernetHelper.GetEthernetParameter(CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_HOSTNAME, 0);
+                var domainName = CrestronEthernetHelper.GetEthernetParameter(CrestronEthernetHelper.ETHERNET_PARAMETER_TO_GET.GET_DOMAIN_NAME, 0);
+
+                //Debug.Console(0, "DomainName: {0} | HostName: {1} | {1}.{0}@{2}", domainName, hostName, ipAddress);
+                CrestronConsole.PrintLine(string.Format("DomainName: {0} | HostName: {1} | {1}.{0}@{2}", domainName, hostName, ipAddress));
+
+                var certificate = utility.CreateSelfSignedCertificate(string.Format("CN={0}.{1}", hostName, domainName), new[] { string.Format("{0}.{1}", hostName, domainName), ipAddress }, new[] { KeyPurposeID.id_kp_serverAuth, KeyPurposeID.id_kp_clientAuth });
+                //Crestron fails to let us do this...perhaps it should be done through their Dll's but haven't tested
+                //Debug.Print($"CreateCert Storing Certificate To My.LocalMachine");
+                //utility.AddCertToStore(certificate, StoreName.My, StoreLocation.LocalMachine);
+                //Debug.Console(0, "CreateCert Saving Cert to \\user\\");
+                CrestronConsole.PrintLine("CreateCert Saving Cert to \\user\\");
+                utility.CertificatePassword = _certificatePassword;
+                utility.WriteCertificate(certificate, @"\user\", _certificateName);
+                //Debug.Console(0, "CreateCert Ending CreateCert");
+                CrestronConsole.PrintLine("CreateCert Ending CreateCert");
+            }
+            catch (Exception ex)
+            {
+                //Debug.Console(0, "WSS CreateCert Failed\r\n{0}\r\n{1}", ex.Message, ex.StackTrace);
+                CrestronConsole.PrintLine(string.Format("WSS CreateCert Failed\r\n{0}\r\n{1}", ex.Message, ex.StackTrace));
+            }
+        }
+
+        public void Emit(LogEvent logEvent)
+        {
+            if (_httpsServer == null || !_httpsServer.IsListening) return;
+
+            var sw = new StringWriter();
+            _textFormatter.Format(logEvent, sw);
+
+            _httpsServer.WebSocketServices.Broadcast(sw.ToString());
+
+        }
+
+        public void StartServerAndSetPort(int port)
+        {
+            Debug.Console(0, "Starting Websocket Server on port: {0}", port);
+
+
+            Start(port, $"\\user\\{_certificateName}.pfx", _certificatePassword);
+        }
+
+        private void Start(int port, string certPath = "", string certPassword = "")
+        {
+            try
+            {
+                _httpsServer = new HttpServer(port, true);
+
+
+                if (!string.IsNullOrWhiteSpace(certPath))
+                {
+                    Debug.Console(0, "Assigning SSL Configuration");
+                    _httpsServer.SslConfiguration = new ServerSslConfiguration(new X509Certificate2(certPath, certPassword))
+                    {
+                        ClientCertificateRequired = false,
+                        CheckCertificateRevocation = false,
+                        EnabledSslProtocols = SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls,
+                        //this is just to test, you might want to actually validate
+                        ClientCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) =>
+                        {
+                            Debug.Console(0, "HTTPS ClientCerticateValidation Callback triggered");
+                            return true;
+                        }
+                    };
+                }
+                Debug.Console(0, "Adding Debug Client Service");
+                _httpsServer.AddWebSocketService<DebugClient>(_path);
+                Debug.Console(0, "Assigning Log Info");
+                _httpsServer.Log.Level = LogLevel.Trace;
+                _httpsServer.Log.Output = (d, s) =>
+                {
+                    uint level;
+
+                    switch(d.Level)
+                    {
+                        case WebSocketSharp.LogLevel.Fatal:
+                            level = 3;
+                            break;
+                        case WebSocketSharp.LogLevel.Error:
+                            level = 2;
+                            break;
+                        case WebSocketSharp.LogLevel.Warn:
+                            level = 1;
+                            break;
+                        case WebSocketSharp.LogLevel.Info:
+                            level = 0;
+                            break;
+                        case WebSocketSharp.LogLevel.Debug:
+                            level = 4;
+                            break;
+                        case WebSocketSharp.LogLevel.Trace:
+                            level = 5;
+                            break;
+                        default:
+                            level = 4;
+                            break;
+                    }
+                    
+                    Debug.Console(level, "{1} {0}\rCaller:{2}\rMessage:{3}\rs:{4}", d.Level.ToString(), d.Date.ToString(), d.Caller.ToString(), d.Message, s);
+                };
+                Debug.Console(0, "Starting");
+
+                _httpsServer.Start();
+                Debug.Console(0, "Ready");
+            }
+            catch (Exception ex)
+            {
+                Debug.Console(0, "WebSocket Failed to start {0}", ex.Message);
+            }
+        }
+
+        public void StopServer()
+        {
+            Debug.Console(0, "Stopping Websocket Server");
+            _httpsServer?.Stop();
+
+            _httpsServer = null;
+        }
+    }
+
+    public static class DebugWebsocketSinkExtensions
+    {
+        public static LoggerConfiguration DebugWebsocketSink(
+                             this LoggerSinkConfiguration loggerConfiguration,
+                                              ITextFormatter formatProvider = null)
+        {
+            return loggerConfiguration.Sink(new DebugWebsocketSink(formatProvider));
+        }
+    }
+
+    public class DebugClient : WebSocketBehavior
+    {
+        private DateTime _connectionTime;
+
+        public TimeSpan ConnectedDuration
+        {
+            get
+            {
+                if (Context.WebSocket.IsAlive)
+                {
+                    return DateTime.Now - _connectionTime;
+                }
+                else
+                {
+                    return new TimeSpan(0);
+                }
+            }
+        }
+
+        public DebugClient()
+        {
+            Debug.Console(0, "DebugClient Created");
+        }
+
+        protected override void OnOpen()
+        {
+            base.OnOpen();
+
+            var url = Context.WebSocket.Url;
+            Debug.Console(0, Debug.ErrorLogLevel.Notice, "New WebSocket Connection from: {0}", url);
+
+            _connectionTime = DateTime.Now;
+        }
+
+        protected override void OnMessage(MessageEventArgs e)
+        {
+            base.OnMessage(e);
+
+            Debug.Console(0, "WebSocket UiClient Message: {0}", e.Data);
+        }
+
+        protected override void OnClose(CloseEventArgs e)
+        {
+            base.OnClose(e);
+
+            Debug.Console(0, Debug.ErrorLogLevel.Notice, "WebSocket UiClient Closing: {0} reason: {1}", e.Code, e.Reason);
+
+        }
+
+        protected override void OnError(WebSocketSharp.ErrorEventArgs e)
+        {
+            base.OnError(e);
+
+            Debug.Console(2, Debug.ErrorLogLevel.Notice, "WebSocket UiClient Error: {0} message: {1}", e.Exception, e.Message);
+        }
+    }
+}