Adds support for recording. Closes #93 (#184)

Author: waldekmastykarz

.vscode/launch.json

@@ -14,7 +14,7 @@
       "args": [],
       "cwd": "${workspaceFolder}/msgraph-developer-proxy",
       // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
-      "console": "internalConsole",
+      "console": "integratedTerminal",
       "stopAtEntry": false,
       "launchSettingsProfile": "Default"
     },

msgraph-developer-proxy-abstractions/PluginEvents.cs

@@ -55,6 +55,33 @@ public OptionsLoadedArgs(InvocationContext context) {
     public InvocationContext Context { get; set; }
 }
 
+public class RequestLog {
+    public string[] Message { get; set; }
+    public MessageType MessageType { get; set; }
+    public LoggingContext? Context { get; set; }
+
+    public RequestLog(string[] message, MessageType messageType, LoggingContext? context)
+    {
+        Message = message ?? throw new ArgumentNullException(nameof(message));
+        MessageType = messageType;
+        Context = context;
+    }
+}
+
+public class RecordingArgs {
+    public RecordingArgs(IEnumerable<RequestLog> requestLogs) {
+        RequestLogs = requestLogs ?? throw new ArgumentNullException(nameof(requestLogs));
+    }
+    public IEnumerable<RequestLog> RequestLogs { get; set; }
+}
+
+public class RequestLogArgs {
+    public RequestLogArgs(RequestLog requestLog) {
+        RequestLog = requestLog ?? throw new ArgumentNullException(nameof(requestLog));
+    }
+    public RequestLog RequestLog { get; set; }
+}
+
 public interface IPluginEvents {
     /// <summary>
     /// Raised while starting the proxy, allows plugins to register command line options
@@ -81,6 +108,14 @@ public interface IPluginEvents {
     /// Raised for all responses
     /// </summary>
     event EventHandler<ProxyResponseArgs>? AfterResponse;
+    /// <summary>
+    /// Raised after request message has been logged.
+    /// </summary>
+    event EventHandler<RequestLogArgs>? AfterRequestLog;
+    /// <summary>
+    /// Raised after recording request logs has stopped.
+    /// </summary>
+    event EventHandler<RecordingArgs>? AfterRecordingStop;
 }
 
 public class PluginEvents : IPluginEvents {
@@ -94,6 +129,10 @@ public class PluginEvents : IPluginEvents {
     public event EventHandler<ProxyResponseArgs>? BeforeResponse;
     /// <inheritdoc />
     public event EventHandler<ProxyResponseArgs>? AfterResponse;
+    /// <inheritdoc />
+    public event EventHandler<RequestLogArgs>? AfterRequestLog;
+    /// <inheritdoc />
+    public event EventHandler<RecordingArgs>? AfterRecordingStop;
 
     public void RaiseInit(InitArgs args) {
         Init?.Invoke(this, args);
@@ -114,4 +153,12 @@ public void RaiseProxyBeforeResponse(ProxyResponseArgs args) {
     public void RaiseProxyAfterResponse(ProxyResponseArgs args) {
         AfterResponse?.Invoke(this, args);
     }
+
+    public void RaiseRequestLogged(RequestLogArgs args) {
+        AfterRequestLog?.Invoke(this, args);
+    }
+
+    public void RaiseRecordingStopped(RecordingArgs args) {
+        AfterRecordingStop?.Invoke(this, args);
+    }
 }

msgraph-developer-proxy/ConsoleLogger.cs

@@ -8,19 +8,21 @@ namespace Microsoft.Graph.DeveloperProxy;
 public class ConsoleLogger : ILogger {
     private readonly ConsoleColor _color;
     private readonly LabelMode _labelMode;
+    private readonly PluginEvents _pluginEvents;
     private readonly string _boxTopLeft = "\u250c ";
     private readonly string _boxLeft = "\u2502 ";
     private readonly string _boxBottomLeft = "\u2514 ";
     // used to align single-line messages
     private readonly string _boxSpacing = "  ";
 
-    private static readonly object lockObject = new object();
+    public static readonly object ConsoleLock = new object();
 
     public LogLevel LogLevel { get; set; }
 
-    public ConsoleLogger(ProxyConfiguration configuration) {
+    public ConsoleLogger(ProxyConfiguration configuration, PluginEvents pluginEvents) {
         _color = Console.ForegroundColor;
         _labelMode = configuration.LabelMode;
+        _pluginEvents = pluginEvents;
         LogLevel = configuration.LogLevel;
     }
 
@@ -72,7 +74,7 @@ public void LogRequest(string[] message, MessageType messageType, LoggingContext
             messageLines.Add($"{context.Session.HttpClient.Request.Method} {context.Session.HttpClient.Request.Url}");
         }
 
-        lock (lockObject) {
+        lock (ConsoleLock) {
             switch (_labelMode) {
                 case LabelMode.Text:
                     WriteBoxedWithInvertedLabels(messageLines.ToArray(), messageType);
@@ -85,6 +87,8 @@ public void LogRequest(string[] message, MessageType messageType, LoggingContext
                     break;
             }
         }
+
+        _pluginEvents.RaiseRequestLogged(new RequestLogArgs(new RequestLog(message, messageType, context)));
     }
 
     public void WriteBoxedWithInvertedLabels(string[] message, MessageType messageType) {

msgraph-developer-proxy/Program.cs

@@ -5,11 +5,11 @@
 using Microsoft.Graph.DeveloperProxy.Abstractions;
 using System.CommandLine;
 
-ILogger logger = new ConsoleLogger(ProxyCommandHandler.Configuration);
+PluginEvents pluginEvents = new PluginEvents();
+ILogger logger = new ConsoleLogger(ProxyCommandHandler.Configuration, pluginEvents);
 IProxyContext context = new ProxyContext(logger);
 ProxyHost proxyHost = new();
 RootCommand rootCommand = proxyHost.GetRootCommand();
-PluginEvents pluginEvents = new PluginEvents();
 PluginLoaderResult loaderResults = new PluginLoader(logger).LoadPlugins(pluginEvents, context);
 
 // have all the plugins init and provide any command line options

msgraph-developer-proxy/ProxyCommandHandler.cs

@@ -12,18 +12,21 @@ namespace Microsoft.Graph.DeveloperProxy;
 public class ProxyCommandHandler : ICommandHandler {
     public Option<int?> Port { get; set; }
     public Option<LogLevel?> LogLevel { get; set; }
+    public Option<bool?> Record { get; set; }
 
     private readonly PluginEvents _pluginEvents;
     private readonly ISet<Regex> _urlsToWatch;
     private readonly ILogger _logger;
 
     public ProxyCommandHandler(Option<int?> port,
                                Option<LogLevel?> logLevel,
+                               Option<bool?> record,
                                PluginEvents pluginEvents,
                                ISet<Regex> urlsToWatch,
                                ILogger logger) {
         Port = port ?? throw new ArgumentNullException(nameof(port));
         LogLevel = logLevel ?? throw new ArgumentNullException(nameof(logLevel));
+        Record = record ?? throw new ArgumentNullException(nameof(record));
         _pluginEvents = pluginEvents ?? throw new ArgumentNullException(nameof(pluginEvents));
         _urlsToWatch = urlsToWatch ?? throw new ArgumentNullException(nameof(urlsToWatch));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
@@ -42,6 +45,10 @@ public async Task<int> InvokeAsync(InvocationContext context) {
         if (logLevel is not null) {
             _logger.LogLevel = logLevel.Value;
         }
+        var record = context.ParseResult.GetValueForOption(Record);
+        if (record is not null) {
+            Configuration.Record = record.Value;
+        }
 
         CancellationToken? cancellationToken = (CancellationToken?)context.BindingContext.GetService(typeof(CancellationToken?));
 

msgraph-developer-proxy/ProxyConfiguration.cs

@@ -22,6 +22,8 @@ public class ProxyConfiguration {
     [JsonPropertyName("labelMode")]
     [JsonConverter(typeof(JsonStringEnumConverter))]
     public LabelMode LabelMode { get; set; } = LabelMode.Text;
+    [JsonPropertyName("record")]
+    public bool Record { get; set; } = false;
     [JsonPropertyName("logLevel")]
     [JsonConverter(typeof(JsonStringEnumConverter))]
     public LogLevel LogLevel { get; set; } = LogLevel.Info;

msgraph-developer-proxy/ProxyEngine.cs

@@ -38,6 +38,9 @@ public static string ProductVersion {
         }
     }
 
+    private bool _isRecording = false;
+    private List<RequestLog> _requestLogs = new List<RequestLog>();
+
     public ProxyEngine(ProxyConfiguration config, ISet<Regex> urlsToWatch, PluginEvents pluginEvents, ILogger logger) {
         _config = config ?? throw new ArgumentNullException(nameof(config));
         _urlsToWatch = urlsToWatch ?? throw new ArgumentNullException(nameof(urlsToWatch));
@@ -95,11 +98,80 @@ public async Task Run(CancellationToken? cancellationToken) {
         _logger.LogInfo("Press CTRL+C to stop the Microsoft Graph Developer Proxy");
         _logger.LogInfo("");
         Console.CancelKeyPress += Console_CancelKeyPress;
-        // wait for the proxy to stop
-        Console.ReadLine();
+
+        if (_config.Record) {
+            StartRecording();
+        }
+        _pluginEvents.AfterRequestLog += AfterRequestLog;
+
+        // we need this check or proxy will fail with an exception
+        // when run for example in VSCode's integrated terminal
+        if (!Console.IsInputRedirected) {
+            ReadKeys();
+        }
         while (_proxyServer.ProxyRunning) { Thread.Sleep(10); }
     }
 
+    private void AfterRequestLog(object? sender, RequestLogArgs e) {
+        if (!_isRecording)
+        {
+            return;
+        }
+
+        _requestLogs.Add(e.RequestLog);
+    }
+
+    private void ReadKeys() {
+        ConsoleKey key;
+        do {
+            key = Console.ReadKey(true).Key;
+            if (key == ConsoleKey.R) {
+                StartRecording();
+            }
+            else if (key == ConsoleKey.S) {
+                StopRecording();
+            }
+        } while (key != ConsoleKey.Escape);
+    }
+
+    private void StartRecording() {
+        if (_isRecording) {
+            return;
+        }
+
+        _isRecording = true;
+        PrintRecordingIndicator();
+    }
+
+    private void StopRecording() {
+        if (!_isRecording) {
+            return;
+        }
+
+        _isRecording = false;
+        PrintRecordingIndicator();
+        // clone the list so that we can clear the original
+        // list in case a new recording is started, and
+        // we let plugins handle previously recorded requests
+        var clonedLogs = _requestLogs.ToArray();
+        _requestLogs.Clear();
+        _pluginEvents.RaiseRecordingStopped(new RecordingArgs(clonedLogs));
+    }
+
+    private void PrintRecordingIndicator() {
+        lock (ConsoleLogger.ConsoleLock) {
+            if (_isRecording) {
+                Console.ForegroundColor = ConsoleColor.Red;
+                Console.Error.Write("◉");
+                Console.ResetColor();
+                Console.Error.WriteLine(" Recording... ");
+            }
+            else {
+                Console.Error.WriteLine("○ Stopped recording");
+            }
+        }
+    }
+
     // Convert strings from config to regexes.
     // From the list of URLs, extract host names and convert them to regexes.
     // We need this because before we decrypt a request, we only have access
@@ -129,6 +201,7 @@ private void LoadHostNamesFromUrls() {
     }
 
     private void Console_CancelKeyPress(object? sender, ConsoleCancelEventArgs e) {
+        StopRecording();
         StopProxy();
     }
 

msgraph-developer-proxy/ProxyHost.cs

@@ -10,6 +10,7 @@ namespace Microsoft.Graph.DeveloperProxy;
 internal class ProxyHost {
     private Option<int?> _portOption;
     private Option<LogLevel?> _logLevelOption;
+    private Option<bool?> _recordOption;
 
     public ProxyHost() {
         _portOption = new Option<int?>("--port", "The port for the proxy server to listen on");
@@ -23,18 +24,21 @@ public ProxyHost() {
                 input.ErrorMessage = $"{input.Tokens.First().Value} is not a valid log level. Allowed values are: {string.Join(", ", Enum.GetNames(typeof(LogLevel)))}";
             }
         });
+
+        _recordOption = new Option<bool?>("--record", "Use this option to record all request logs");
     }
 
     public RootCommand GetRootCommand() {
         var command = new RootCommand {
             _portOption,
-            _logLevelOption
+            _logLevelOption,
+            _recordOption
         };
         command.Description = "Microsoft Graph Developer Proxy is a command line tool that simulates real world behaviors of Microsoft Graph and other APIs, locally.";
 
         return command;
     }
 
-    public ProxyCommandHandler GetCommandHandler(PluginEvents pluginEvents, ISet<Regex> urlsToWatch, ILogger logger) => new ProxyCommandHandler(_portOption, _logLevelOption, pluginEvents, urlsToWatch, logger);
+    public ProxyCommandHandler GetCommandHandler(PluginEvents pluginEvents, ISet<Regex> urlsToWatch, ILogger logger) => new ProxyCommandHandler(_portOption, _logLevelOption, _recordOption, pluginEvents, urlsToWatch, logger);
 }