Add basic diagnostic logging support

src/PowerShellEditorServices.Host/Program.cs

@@ -4,6 +4,7 @@
 //
 
 using Microsoft.PowerShell.EditorServices.Transport.Stdio;
+using Microsoft.PowerShell.EditorServices.Utility;
 using System;
 using System.Diagnostics;
 using System.Linq;
@@ -38,11 +39,30 @@ static void Main(string[] args)
                 }
             }
 #endif
+            // Catch unhandled exceptions for logging purposes
+            AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
+
+            // Initialize the logger
+            // TODO: Set the level based on command line parameter
+            Logger.Initialize(minimumLogLevel: LogLevel.Verbose);
+            Logger.Write(LogLevel.Normal, "PowerShell Editor Services Host started!");
 
             // TODO: Select host, console host, and transport based on command line arguments
 
             IHost host = new StdioHost();
             host.Start();
         }
+
+        static void CurrentDomain_UnhandledException(
+            object sender, 
+            UnhandledExceptionEventArgs e)
+        {
+            // Log the exception
+            Logger.Write(
+                LogLevel.Error,
+                string.Format(
+                    "FATAL UNHANDLED EXCEPTION:\r\n\r\n{0}",
+                    e.ExceptionObject.ToString()));
+        }
     }
 }

src/PowerShellEditorServices.Transport.Stdio/Message/MessageParser.cs

@@ -45,6 +45,13 @@ public MessageBase ParseMessage(string messageJson)
             // Parse the JSON string to a JObject
             JObject messageObject = JObject.Parse(messageJson);
 
+            // Log the message
+            Logger.Write(
+                LogLevel.Verbose,
+                string.Format(
+                    "PARSE MESSAGE:\r\n\r\n{0}",
+                    messageObject.ToString(Formatting.Indented)));
+
             // Get the message type and name from the JSON object
             if (!this.TryGetMessageTypeAndName(
                 messageObject,

src/PowerShellEditorServices.Transport.Stdio/Message/MessageWriter.cs

@@ -5,6 +5,7 @@
 
 using Microsoft.PowerShell.EditorServices.Utility;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using System.IO;
 using System.Text;
 
@@ -18,6 +19,10 @@ public class MessageWriter
         private bool includeContentLength;
         private MessageTypeResolver messageTypeResolver;
 
+        private JsonSerializer loggingSerializer = 
+            JsonSerializer.Create(
+                Constants.JsonSerializerSettings);
+
         #endregion
 
         #region Constructors
@@ -57,8 +62,18 @@ public void WriteMessage(MessageBase messageToWrite)
             // Insert the message's type name before serializing
             messageToWrite.PayloadType = messageTypeName;
 
+            // Log the JSON representation of the message
+            Logger.Write(
+                LogLevel.Verbose,
+                string.Format(
+                    "WRITE MESSAGE:\r\n\r\n{0}",
+                    JsonConvert.SerializeObject(
+                        messageToWrite,
+                        Formatting.Indented,
+                        Constants.JsonSerializerSettings)));
+
             // Serialize the message
-            string serializedMessage = 
+            string serializedMessage =
                 JsonConvert.SerializeObject(
                     messageToWrite,
                     Constants.JsonSerializerSettings);

src/PowerShellEditorServices/PowerShellEditorServices.csproj

@@ -90,6 +90,7 @@
     <Compile Include="Session\ScriptFileMarker.cs" />
     <Compile Include="Session\ScriptRegion.cs" />
     <Compile Include="Session\Workspace.cs" />
+    <Compile Include="Utility\Logger.cs" />
     <Compile Include="Utility\Validate.cs" />
   </ItemGroup>
   <ItemGroup>

src/PowerShellEditorServices/Utility/Logger.cs

@@ -0,0 +1,180 @@
+//
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+//
+
+using System;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace Microsoft.PowerShell.EditorServices.Utility
+{
+    /// <summary>
+    /// Defines the level indicators for log messages.
+    /// </summary>
+    public enum LogLevel
+    {
+        /// <summary>
+        /// Indicates a verbose log message.
+        /// </summary>
+        Verbose,
+
+        /// <summary>
+        /// Indicates a normal, non-verbose log message.
+        /// </summary>
+        Normal,
+
+        /// <summary>
+        /// Indicates a warning message.
+        /// </summary>
+        Warning,
+
+        /// <summary>
+        /// Indicates an error message.
+        /// </summary>
+        Error
+    }
+
+    /// <summary>
+    /// Provides a simple logging interface.  May be replaced with a
+    /// more robust solution at a later date.
+    /// </summary>
+    public static class Logger
+    {
+        private static LogWriter logWriter;
+
+        /// <summary>
+        /// Initializes the Logger for the current session.
+        /// </summary>
+        /// <param name="logFilePath">
+        /// Optional. Specifies the path at which log messages will be written.
+        /// </param>
+        /// <param name="minimumLogLevel">
+        /// Optional. Specifies the minimum log message level to write to the log file.
+        /// </param>
+        public static void Initialize(
+            string logFilePath = "EditorServices.log",
+            LogLevel minimumLogLevel = LogLevel.Normal)
+        {
+            if (logWriter != null)
+            {
+                logWriter.Dispose();
+            }
+
+            // TODO: Parameterize this
+            logWriter = 
+                new LogWriter(
+                    minimumLogLevel, 
+                    logFilePath,
+                    true);
+        }
+
+        /// <summary>
+        /// Closes the Logger.
+        /// </summary>
+        public static void Close()
+        {
+            if (logWriter != null)
+            {
+                logWriter.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Writes a message to the log file.
+        /// </summary>
+        /// <param name="logLevel">The level at which the message will be written.</param>
+        /// <param name="logMessage">The message text to be written.</param>
+        /// <param name="callerName">The name of the calling method.</param>
+        /// <param name="callerSourceFile">The source file path where the calling method exists.</param>
+        /// <param name="callerLineNumber">The line number of the calling method.</param>
+        public static void Write(
+            LogLevel logLevel,
+            string logMessage,
+            [CallerMemberName] string callerName = null, 
+            [CallerFilePath] string callerSourceFile = null,
+            [CallerLineNumber] int callerLineNumber = 0)
+        {
+            if (logWriter != null)
+            {
+                logWriter.Write(
+                    logLevel,
+                    logMessage,
+                    callerName,
+                    callerSourceFile,
+                    callerLineNumber);
+            }
+        }
+    }
+
+    internal class LogWriter : IDisposable
+    {
+        private TextWriter textWriter;
+        private LogLevel minimumLogLevel = LogLevel.Verbose;
+
+        public LogWriter(LogLevel minimumLogLevel, string logFilePath, bool deleteExisting)
+        {
+            this.minimumLogLevel = minimumLogLevel;
+
+            // Ensure that we have a usable log file path
+            if (!Path.IsPathRooted(logFilePath))
+            {
+                logFilePath =
+                    Path.Combine(
+                        AppDomain.CurrentDomain.BaseDirectory,
+                        logFilePath);
+            }
+
+            // Open the log file for writing with UTF8 encoding
+            this.textWriter =
+                new StreamWriter(
+                    new FileStream(
+                        logFilePath,
+                        deleteExisting ?
+                            FileMode.Create :
+                            FileMode.Append),
+                    Encoding.UTF8);
+        }
+
+        public void Write(
+            LogLevel logLevel, 
+            string logMessage, 
+            string callerName = null, 
+            string callerSourceFile = null,
+            int callerLineNumber = 0)
+        {
+            if (logLevel >= this.minimumLogLevel)
+            {
+                // Print the timestamp and log level
+                this.textWriter.WriteLine(
+                    "{0} [{1}] - Method \"{2}\" at line {3} of {4}\r\n",
+                    DateTime.Now,
+                    logLevel.ToString().ToUpper(),
+                    callerName,
+                    callerLineNumber,
+                    callerSourceFile);
+
+                // Print out indented message lines
+                foreach (var messageLine in logMessage.Split('\n'))
+                {
+                    this.textWriter.WriteLine("    " + messageLine.TrimEnd());
+                }
+
+                // Finish with a newline and flush the writer
+                this.textWriter.WriteLine();
+                this.textWriter.Flush();
+            }
+        }
+
+        public void Dispose()
+        {
+            if (this.textWriter != null)
+            {
+                this.textWriter.Flush();
+                this.textWriter.Dispose();
+                this.textWriter = null;
+            }
+        }
+    }
+}

test/PowerShellEditorServices.Test/PowerShellEditorServices.Test.csproj

@@ -64,6 +64,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Console\ConsoleServiceTests.cs" />
     <Compile Include="Session\ScriptFileTests.cs" />
+    <Compile Include="Utility\LoggerTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />