[Messaging] Make output configurable depending on message metadata

Source/messaging/MessageUnit.cpp

@@ -22,6 +22,12 @@
 
 namespace Thunder {
 
+ENUM_CONVERSION_BEGIN(Thunder::Messaging::MessageUnit::OutputMode)
+    { Thunder::Messaging::MessageUnit::PLUGIN, _TXT("plugin") },
+    { Thunder::Messaging::MessageUnit::DIRECT, _TXT("direct") },
+    { Thunder::Messaging::MessageUnit::BOTH,   _TXT("both")   },
+ENUM_CONVERSION_END(Thunder::Messaging::MessageUnit::OutputMode)
+
     namespace Messaging {
 
         uint16_t MessageUnit::Serialize(uint8_t* buffer, const uint16_t length, const string& module)
@@ -359,30 +365,43 @@ namespace Thunder {
         */
         /* virtual */ void MessageUnit::Push(const Core::Messaging::MessageInfo& messageInfo, const Core::Messaging::IEvent* message)
         {
-            //logging messages can happen in Core, meaning, otherside plugin can be not started yet
-            //those should be just printed
-            if (_dataBuffer == nullptr) {
+            const MessageUnit::OutputMode outputMode = _settings.EffectiveOutput(messageInfo);
+
+            const bool sendDirect   = (outputMode == MessageUnit::DIRECT) || (outputMode == MessageUnit::BOTH);
+            const bool sendToPlugin = (outputMode == MessageUnit::PLUGIN) || (outputMode == MessageUnit::BOTH);
+
+            if (sendDirect == true) {
                 _direct.Output(messageInfo, message);
-            } else {
-                const uint16_t messageSize = _settings.MessageSize();
-                ASSERT(messageSize != 0);
-                uint8_t* serializationBuffer = static_cast<uint8_t*>(ALLOCA(messageSize));
-                uint16_t length = 0;
+            }
 
-                ASSERT(messageInfo.Type() != Core::Messaging::Metadata::type::INVALID);
+            if (sendToPlugin == true) {
 
-                length = messageInfo.Serialize(serializationBuffer, messageSize);
+                if (_dataBuffer != nullptr) {
+                    const uint16_t messageSize = _settings.MessageSize();
+                    ASSERT(messageSize != 0);
+                    uint8_t* serializationBuffer = static_cast<uint8_t*>(ALLOCA(messageSize));
+                    uint16_t length = 0;
 
-                //only serialize message if the information could fit
-                if (length != 0) {
-                    length += message->Serialize(serializationBuffer + length, messageSize - length);
+                    ASSERT(messageInfo.Type() != Core::Messaging::Metadata::type::INVALID);
 
-                    if (_dataBuffer->PushData(length, serializationBuffer) != Core::ERROR_NONE) {
-                        TRACE_L1("Unable to push message data!");
+                    length = messageInfo.Serialize(serializationBuffer, messageSize);
+
+                    //only serialize message if the information could fit
+                    if (length != 0) {
+                        length += message->Serialize(serializationBuffer + length, messageSize - length);
+
+                        if (_dataBuffer->PushData(length, serializationBuffer) != Core::ERROR_NONE) {
+                            TRACE_L1("Unable to push message data!");
+                        }
+                    }
+                    else {
+                        TRACE_L1("Unable to push data, buffer is too small!");
                     }
                 }
-                else {
-                    TRACE_L1("Unable to push data, buffer is too small!");
+                else if (sendDirect == false) {
+                    // Buffer unavailable (early startup or DirectOutput mode without plugin overrides):
+                    // fall back to direct output if we haven't already sent it directly.
+                    _direct.Output(messageInfo, message);
                 }
             }
         }