Implement support in the LSIF generator for logging to stderr

src/Features/Lsif/Generator/Generator.cs

@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.Writing;
 using Microsoft.CodeAnalysis.LanguageService;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.Extensions.Logging;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using Roslyn.Utilities;
 using LspProtocol = Microsoft.VisualStudio.LanguageServer.Protocol;
@@ -53,18 +54,18 @@ internal sealed class Generator
         };
 
         private readonly ILsifJsonWriter _lsifJsonWriter;
-        private readonly TextWriter _logFile;
+        private readonly ILogger _logger;
         private readonly IdFactory _idFactory = new IdFactory();
 
-        private Generator(ILsifJsonWriter lsifJsonWriter, TextWriter logFile)
+        private Generator(ILsifJsonWriter lsifJsonWriter, ILogger logger)
         {
             _lsifJsonWriter = lsifJsonWriter;
-            _logFile = logFile;
+            _logger = logger;
         }
 
-        public static Generator CreateAndWriteCapabilitiesVertex(ILsifJsonWriter lsifJsonWriter, TextWriter logFile)
+        public static Generator CreateAndWriteCapabilitiesVertex(ILsifJsonWriter lsifJsonWriter, ILogger logger)
         {
-            var generator = new Generator(lsifJsonWriter, logFile);
+            var generator = new Generator(lsifJsonWriter, logger);
 
             // Pass the set of supported SemanticTokenTypes. Order must match the order used for serialization of
             // semantic tokens array. This array is analogous to the equivalent array in
@@ -167,8 +168,7 @@ public async Task GenerateForProjectAsync(
                         var exception = tasks[i].Exception!.InnerExceptions.Single();
                         exceptions.Add(exception);
 
-                        await _logFile.WriteLineAsync($"Exception while processing {documents[i].FilePath}:");
-                        await _logFile.WriteLineAsync(exception.ToString());
+                        _logger.LogError(exception, $"Exception while processing {documents[i].FilePath}");
                     }
                 }
 

src/Features/Lsif/Generator/Logging/LsifFormatLogger.cs

@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.IO;
+using Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.Writing;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.Logging
+{
+    internal sealed class LsifFormatLogger : ILogger
+    {
+        private readonly TextWriter _writer;
+        private readonly object _writerGate = new object();
+
+        public LsifFormatLogger(TextWriter writer)
+        {
+            _writer = writer;
+        }
+
+        public IDisposable BeginScope<TState>(TState state)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsEnabled(LogLevel logLevel)
+        {
+            return logLevel >= LogLevel.Information;
+        }
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            var message = formatter(state, exception);
+
+            var severity = logLevel switch { LogLevel.Information => "Info", LogLevel.Warning => "Warning", LogLevel.Error => "Error", LogLevel.Critical => "Critical", _ => throw ExceptionUtilities.UnexpectedValue(logLevel) };
+
+            var command = new CommandWithParameters("log",
+                new LogCommandParameters(severity, message, exception?.Message, exception?.GetType().ToString(), exception?.StackTrace));
+            var serializedCommand = JsonConvert.SerializeObject(command, LineModeLsifJsonWriter.SerializerSettings);
+
+            lock (_writerGate)
+            {
+                _writer.Write(serializedCommand);
+            }
+        }
+
+        private sealed record CommandWithParameters(string Command, object Parameters);
+        private sealed record LogCommandParameters(
+            string Severity,
+            string Message,
+            string? ExceptionMessage,
+            string? ExceptionType,
+            string? CallStack);
+    }
+}

src/Features/Lsif/Generator/Logging/PlainTextLogger.cs

@@ -0,0 +1,46 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.IO;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.CodeAnalysis.LanguageServerIndexFormat.Generator.Logging
+{
+    internal sealed class PlainTextLogger : ILogger
+    {
+        private readonly TextWriter _writer;
+        private readonly object _gate = new object();
+
+        public PlainTextLogger(TextWriter writer)
+        {
+            _writer = writer;
+        }
+
+        public IDisposable BeginScope<TState>(TState state)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsEnabled(LogLevel logLevel)
+        {
+            return true;
+        }
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+        {
+            // Not all formatters will actually include the exception even if we pass it through, so include it here.
+            var message = formatter(state, exception);
+            var exceptionString = exception?.ToString();
+
+            lock (_gate)
+            {
+                _writer.WriteLine(message);
+
+                if (exceptionString != null)
+                    _writer.WriteLine(exceptionString);
+            }
+        }
+    }
+}