Add logging for the VST3 plugin

src/common/communication/vst3.h

@@ -89,10 +89,7 @@ class Vst3MessageHandler : public AdHocSocketHandler<Thread> {
 
         if (logging) {
             auto [logger, is_host_vst] = *logging;
-            // TODO: Log the request
-            // logger.log_event(is_dispatch, opcode, index, value, payload,
-            // option,
-            //                  value_payload);
+            logger.log_request(is_host_vst, object);
         }
 
         // A socket only handles a single request at a time as to prevent
@@ -111,11 +108,7 @@ class Vst3MessageHandler : public AdHocSocketHandler<Thread> {
 
         if (logging) {
             auto [logger, is_host_vst] = *logging;
-            // TODO: Log the response
-            // logger.log_event_response(is_dispatch, opcode,
-            //                           response.return_value,
-            //                           response.payload,
-            //                           response.value_payload);
+            logger.log_response(!is_host_vst, response);
         }
 
         return response;
@@ -152,23 +145,22 @@ class Vst3MessageHandler : public AdHocSocketHandler<Thread> {
             [&](boost::asio::local::stream_protocol::socket& socket) {
                 auto request = read_object<Request>(socket);
                 if (logging) {
-                    auto [logger, is_host_vst] = *logging;
-                    // TODO: Log the request, use the visitor with an auto
-                    //       lambda so we can use the same overloads as we use
-                    //       in `send_message()`
-                    // logger.log_event(is_dispatch, opcode, index, value,
-                    // payload, option,
-                    //                  value_payload);
+                    std::visit(
+                        [&](const auto& object) {
+                            auto [logger, is_host_vst] = *logging;
+                            logger.log_request(is_host_vst, object);
+                        },
+                        request);
                 }
 
                 Response response = callback(request);
                 if (logging) {
-                    // TODO: Log the response, use the visitor with an auto
-                    //       lambda so we can use the same overloads as we use
-                    //       in `send_message()`
-                    // logger.log_event_response(
-                    //     is_dispatch, event.opcode, response.return_value,
-                    //     response.payload, response.value_payload);
+                    std::visit(
+                        [&](const auto& object) {
+                            auto [logger, is_host_vst] = *logging;
+                            logger.log_response(!is_host_vst, object);
+                        },
+                        response);
                 }
 
                 write_object(socket, response);

src/common/logging/vst3.cpp

@@ -16,4 +16,28 @@
 
 #include "vst3.h"
 
+#include <sstream>
+
+// TODO: Reconsider the output format
+// TODO: Maybe think of an alterantive that's a little less boilerplaty
+
 Vst3Logger::Vst3Logger(Logger& generic_logger) : logger(generic_logger) {}
+
+void Vst3Logger::log_request(bool is_host_vst, const WantsConfiguration&) {
+    if (BOOST_UNLIKELY(logger.verbosity >= Logger::Verbosity::most_events)) {
+        std::ostringstream message;
+        message << get_log_prefix(is_host_vst)
+                << " >> Requesting <Configuration>";
+
+        log(message.str());
+    }
+}
+
+void Vst3Logger::log_response(bool is_host_vst, const Configuration&) {
+    if (BOOST_UNLIKELY(logger.verbosity >= Logger::Verbosity::most_events)) {
+        std::ostringstream message;
+        message << get_log_prefix(is_host_vst) << "    <Configuration>";
+
+        log(message.str());
+    }
+}

src/common/logging/vst3.h

@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include "../serialization/vst3.h"
 #include "common.h"
 
 /**
@@ -37,7 +38,24 @@ class Vst3Logger {
      */
     inline void log_trace(const std::string& message) { logger.log(message); }
 
-    // TODO: Logging interface for VST3 plugins
+    // For every object we send using `Vst3MessageHandler` we have overloads
+    // that print information about the request and the response. The boolean
+    // flag here indicates whether the request was initiated on the host side
+    // (what we'll call a control message).
+
+    void log_request(bool is_host_vst, const WantsConfiguration&);
+
+    void log_response(bool is_host_vst, const Configuration&);
 
     Logger& logger;
+
+   private:
+    /**
+     * Get the `host -> vst` or `vst -> host` prefix based on the boolean flag
+     * we pass to every logging function so we don't have to repeat it
+     * everywhere.
+     */
+    inline std::string get_log_prefix(bool is_host_vst) {
+        return is_host_vst ? "[host -> vst]" : "[vst -> host]";
+    }
 };