Claude/route logging diagnostics

adapters/describe.json

@@ -12,7 +12,7 @@
             {
                 "id": 0,
                 "ip": "127.0.0.1",
-                "persistent": false,
+                "persistent": true,
                 "port": 502,
                 "timeout": 1000,
                 "type": "tcp"
@@ -23,7 +23,7 @@
                 "connectionId": 0,
                 "consecutiveMax": 125,
                 "id": 1,
-                "int32LittleEndian": false,
+                "int32LittleEndian": true,
                 "slaveId": 1
             }
         ],

adapters/json-rpc-spec.md

@@ -338,7 +338,7 @@ Notifications are sent by the adapter to the client without a corresponding requ
 
 ### `adapter.diagnostic`
 
-_(Reserved for future use.)_ Carries a log or diagnostic message from the adapter.
+Carries a log or diagnostic message from the adapter. Emitted for every Qt log message (`qDebug`, `qInfo`, `qWarning`, `qCritical`, `qFatal`) produced during adapter operation.
 
 ```json
 {
@@ -356,6 +356,7 @@ _(Reserved for future use.)_ Carries a log or diagnostic message from the adapte
 | `"debug"` | Verbose internal trace |
 | `"info"` | Informational |
 | `"warning"` | Non-fatal issue |
+| `"error"` | Critical or fatal error |
 
 ---
 

src/ProtocolAdapter/adapterclient.cpp

@@ -4,7 +4,8 @@
 
 #include <QJsonArray>
 
-AdapterClient::AdapterClient(AdapterProcess* pProcess, QObject* parent) : QObject(parent), _pProcess(pProcess)
+AdapterClient::AdapterClient(AdapterProcess* pProcess, QObject* parent, int handshakeTimeoutMs)
+    : QObject(parent), _pProcess(pProcess), _handshakeTimeoutMs(handshakeTimeoutMs)
 {
     Q_ASSERT(pProcess);
     _pProcess->setParent(this);
@@ -16,6 +17,7 @@ AdapterClient::AdapterClient(AdapterProcess* pProcess, QObject* parent) : QObjec
     connect(_pProcess, &AdapterProcess::errorReceived, this, &AdapterClient::onErrorReceived);
     connect(_pProcess, &AdapterProcess::processError, this, &AdapterClient::onProcessError);
     connect(_pProcess, &AdapterProcess::processFinished, this, &AdapterClient::onProcessFinished);
+    connect(_pProcess, &AdapterProcess::notificationReceived, this, &AdapterClient::onNotificationReceived);
 }
 
 AdapterClient::~AdapterClient() = default;
@@ -35,7 +37,7 @@ void AdapterClient::prepareAdapter(const QString& adapterPath)
 
     qCInfo(scopeComm) << "AdapterClient: process started, sending initialize";
     _state = State::INITIALIZING;
-    _handshakeTimer.start(cHandshakeTimeoutMs);
+    _handshakeTimer.start(_handshakeTimeoutMs);
     _pProcess->sendRequest("adapter.initialize", QJsonObject());
 }
 
@@ -50,7 +52,7 @@ void AdapterClient::provideConfig(QJsonObject config, QStringList registerExpres
     _pendingExpressions = registerExpressions;
     _pendingConfig = config;
     _state = State::CONFIGURING;
-    _handshakeTimer.start(cHandshakeTimeoutMs);
+    _handshakeTimer.start(_handshakeTimeoutMs);
     QJsonObject params;
     params["config"] = _pendingConfig;
     _pProcess->sendRequest("adapter.configure", params);
@@ -91,12 +93,13 @@ void AdapterClient::stopSession()
     {
         _state = State::STOPPING;
         _pProcess->sendRequest("adapter.shutdown", QJsonObject());
+        _handshakeTimer.start(_handshakeTimeoutMs);
     }
     else
     {
+        _state = State::STOPPING;
         _pProcess->stop();
-        _state = State::IDLE;
-        emit sessionStopped();
+        /* sessionStopped is emitted from onProcessFinished once the process exits */
     }
 }
 
@@ -111,8 +114,10 @@ void AdapterClient::onResponseReceived(int id, const QString& method, const QJso
     {
         qCWarning(scopeComm) << "AdapterClient: unexpected non-object result for" << method;
         _handshakeTimer.stop();
+        /* Set IDLE before stop() so onProcessFinished's IDLE guard suppresses any
+           duplicate sessionError emission when the process exits asynchronously. */
         _state = State::IDLE;
-        QTimer::singleShot(0, this, [this]() { _pProcess->stop(); });
+        _pProcess->stop();
         emit sessionError(QString("Unexpected non-object result for %1").arg(method));
     }
 }
@@ -125,8 +130,10 @@ void AdapterClient::onErrorReceived(int id, const QString& method, const QJsonOb
     qCWarning(scopeComm) << "AdapterClient: error for" << method << ":" << errorMsg;
 
     State previousState = _state;
+    /* Set IDLE before stop() so onProcessFinished's IDLE guard suppresses any
+       duplicate sessionError emission when the process exits asynchronously. */
     _state = State::IDLE;
-    QTimer::singleShot(0, this, [this]() { _pProcess->stop(); });
+    _pProcess->stop();
 
     if (previousState != State::STOPPING)
     {
@@ -137,14 +144,22 @@ void AdapterClient::onErrorReceived(int id, const QString& method, const QJsonOb
 void AdapterClient::onProcessError(const QString& message)
 {
     _handshakeTimer.stop();
-    _state = State::IDLE;
-    emit sessionError(message);
+    if (_state != State::STOPPING)
+    {
+        _state = State::IDLE;
+        emit sessionError(message);
+    }
 }
 
 void AdapterClient::onProcessFinished()
 {
     _handshakeTimer.stop();
-    if (_state != State::IDLE)
+    if (_state == State::STOPPING)
+    {
+        _state = State::IDLE;
+        emit sessionStopped();
+    }
+    else if (_state != State::IDLE)
     {
         _state = State::IDLE;
         emit sessionError("Adapter process exited unexpectedly");
@@ -154,9 +169,35 @@ void AdapterClient::onProcessFinished()
 void AdapterClient::onHandshakeTimeout()
 {
     qCWarning(scopeComm) << "AdapterClient: handshake timed out in state" << static_cast<int>(_state);
+    bool wasStopping = (_state == State::STOPPING);
     _state = State::IDLE;
-    QTimer::singleShot(0, this, [this]() { _pProcess->stop(); });
-    emit sessionError("Adapter handshake timed out");
+    _pProcess->stop();
+    if (wasStopping)
+    {
+        emit sessionStopped();
+    }
+    else
+    {
+        emit sessionError("Adapter handshake timed out");
+    }
+}
+
+void AdapterClient::onNotificationReceived(QString method, QJsonValue params)
+{
+    if (method != QStringLiteral("adapter.diagnostic"))
+    {
+        return;
+    }
+
+    if (!params.isObject())
+    {
+        qCWarning(scopeComm) << "AdapterClient: adapter.diagnostic params is not an object";
+        return;
+    }
+
+    QJsonObject obj = params.toObject();
+    emit diagnosticReceived(obj.value(QStringLiteral("level")).toString(),
+                            obj.value(QStringLiteral("message")).toString());
 }
 
 void AdapterClient::handleLifecycleResponse(const QString& method, const QJsonObject& result)
@@ -215,8 +256,7 @@ void AdapterClient::handleLifecycleResponse(const QString& method, const QJsonOb
     {
         qCInfo(scopeComm) << "AdapterClient: shutdown acknowledged";
         _pProcess->stop();
-        _state = State::IDLE;
-        emit sessionStopped();
+        /* sessionStopped is emitted from onProcessFinished once the process exits */
     }
     else
     {

src/ProtocolAdapter/adapterclient.h

@@ -26,7 +26,7 @@ class AdapterClient : public QObject
     Q_OBJECT
 
 public:
-    explicit AdapterClient(AdapterProcess* pProcess, QObject* parent = nullptr);
+    explicit AdapterClient(AdapterProcess* pProcess, QObject* parent = nullptr, int handshakeTimeoutMs = 10000);
     ~AdapterClient();
 
     /*!
@@ -71,7 +71,10 @@ class AdapterClient : public QObject
     void requestStatus();
 
     /*!
-     * \brief Send adapter.shutdown and terminate the adapter process.
+     * \brief Send adapter.shutdown and signal the adapter process to stop.
+     *
+     * The sessionStopped() signal is emitted asynchronously once the process
+     * has fully exited.
      */
     void stopSession();
 
@@ -114,6 +117,13 @@ class AdapterClient : public QObject
      */
     void sessionStopped();
 
+    /*!
+     * \brief Emitted when an adapter.diagnostic notification is received from the adapter.
+     * \param level Severity level string: "debug", "info", or "warning".
+     * \param message The diagnostic message from the adapter.
+     */
+    void diagnosticReceived(QString level, QString message);
+
 protected:
     enum class State
     {
@@ -135,6 +145,7 @@ private slots:
     void onProcessError(const QString& message);
     void onProcessFinished();
     void onHandshakeTimeout();
+    void onNotificationReceived(QString method, QJsonValue params);
 
 private:
     void handleLifecycleResponse(const QString& method, const QJsonObject& result);
@@ -143,6 +154,7 @@ private slots:
 
     AdapterProcess* _pProcess;
     QTimer _handshakeTimer;
+    int _handshakeTimeoutMs;
     QJsonObject _pendingConfig;
     QStringList _pendingExpressions;
 };

src/ProtocolAdapter/adapterprocess.cpp

@@ -3,14 +3,25 @@
 #include "util/scopelogging.h"
 
 #include <QJsonDocument>
+#include <QTimer>
 
 static constexpr int cStartTimeoutMs = 3000;
+static constexpr int cStopTimeoutMs = 3000;
 
 AdapterProcess::AdapterProcess(QObject* parent) : QObject(parent)
 {
     _pProcess = new QProcess(this);
     _pFramingReader = new FramingReader(this);
 
+    _pKillTimer = new QTimer(this);
+    _pKillTimer->setSingleShot(true);
+    connect(_pKillTimer, &QTimer::timeout, this, [this]() {
+        if (_pProcess->state() != QProcess::NotRunning)
+        {
+            _pProcess->kill();
+        }
+    });
+
     connect(_pProcess, &QProcess::readyReadStandardOutput, this, &AdapterProcess::onReadyReadStdout);
     connect(_pProcess, &QProcess::readyReadStandardError, this, &AdapterProcess::onReadyReadStderr);
     connect(_pProcess, &QProcess::finished, this, &AdapterProcess::onProcessFinished);
@@ -25,6 +36,7 @@ bool AdapterProcess::start(const QString& path)
         return true;
     }
 
+    _pKillTimer->stop();
     _pendingMethods.clear();
     _nextRequestId = 1;
 
@@ -49,11 +61,8 @@ void AdapterProcess::stop()
     if (_pProcess->state() != QProcess::NotRunning)
     {
         _pProcess->closeWriteChannel();
-        if (!_pProcess->waitForFinished(3000))
-        {
-            _pProcess->kill();
-            _pProcess->waitForFinished(1000);
-        }
+        _pKillTimer->stop();
+        _pKillTimer->start(cStopTimeoutMs);
     }
 }
 
@@ -100,11 +109,10 @@ bool AdapterProcess::writeFramed(const QByteArray& json)
     qint64 written = _pProcess->write(frame);
     if (written != frame.size())
     {
-        emit processError(
-            QString("Failed to write to adapter process (wrote %1 of %2 bytes, error: %3)")
-                .arg(written)
-                .arg(frame.size())
-                .arg(_pProcess->errorString()));
+        emit processError(QString("Failed to write to adapter process (wrote %1 of %2 bytes, error: %3)")
+                            .arg(written)
+                            .arg(frame.size())
+                            .arg(_pProcess->errorString()));
         return false;
     }
     return true;
@@ -171,5 +179,6 @@ void AdapterProcess::onProcessFinished(int exitCode, QProcess::ExitStatus exitSt
 {
     qCInfo(scopeComm) << "AdapterProcess: process finished, exit code:" << exitCode << "status:" << exitStatus;
     _pendingMethods.clear();
+    _pKillTimer->stop();
     emit processFinished();
 }

src/ProtocolAdapter/adapterprocess.h

@@ -9,6 +9,7 @@
 #include <QObject>
 #include <QProcess>
 #include <QString>
+#include <QTimer>
 
 /*!
  * \brief Transport layer for an external adapter process communicating via JSON-RPC 2.0 over stdio.
@@ -37,7 +38,11 @@ class AdapterProcess : public QObject
     virtual bool start(const QString& path);
 
     /*!
-     * \brief Kill the adapter process and wait for it to finish.
+     * \brief Signal the adapter process to stop and return immediately.
+     *
+     * Closes stdin so the adapter exits cleanly. If it has not exited within
+     * the stop timeout, it is killed. The \c processFinished signal is emitted
+     * asynchronously when the process actually exits.
      */
     virtual void stop();
 
@@ -100,6 +105,7 @@ private slots:
     bool writeFramed(const QByteArray& json);
 
     QProcess* _pProcess;
+    QTimer* _pKillTimer;
     FramingReader* _pFramingReader;
     QMap<int, QString> _pendingMethods;
     int _nextRequestId{ 1 };

src/communication/modbuspoll.cpp

@@ -28,8 +28,10 @@ ModbusPoll::ModbusPoll(SettingsModel* pSettingsModel, QObject* parent) : QObject
     connect(_pAdapterClient, &AdapterClient::sessionError, this, [this](QString message) {
         qCWarning(scopeComm) << "AdapterClient error:" << message;
         _bPollActive = false;
+        disconnect(_pAdapterClient, &AdapterClient::sessionStopped, this, &ModbusPoll::initAdapter);
     });
     connect(_pAdapterClient, &AdapterClient::sessionStopped, this, &ModbusPoll::initAdapter);
+    connect(_pAdapterClient, &AdapterClient::diagnosticReceived, this, &ModbusPoll::onAdapterDiagnostic);
 }
 
 ModbusPoll::~ModbusPoll() = default;
@@ -52,6 +54,10 @@ void ModbusPoll::startCommunication(QList<DataPoint>& registerList)
     _registerList = registerList;
     _bPollActive = true;
 
+    /* Re-establish auto-restart in case it was disconnected by a prior session error */
+    disconnect(_pAdapterClient, &AdapterClient::sessionStopped, this, &ModbusPoll::initAdapter);
+    connect(_pAdapterClient, &AdapterClient::sessionStopped, this, &ModbusPoll::initAdapter);
+
     qCInfo(scopeComm) << QString("Start logging: %1").arg(FormatDateTime::currentDateTime());
 
     resetCommunicationStats();
@@ -119,6 +125,38 @@ void ModbusPoll::onDescribeResult(const QJsonObject& description)
     _pSettingsModel->updateAdapterFromDescribe("modbus", description);
 }
 
+/*! \brief Route an adapter.diagnostic notification to the diagnostics log.
+ *
+ * Maps the adapter's level string to the appropriate Qt logging severity so
+ * the message flows through ScopeLogging into DiagnosticModel.
+ *
+ * \param level Severity string from the adapter: "debug", "info", "warning", or "error".
+ * \param message The diagnostic message text.
+ */
+void ModbusPoll::onAdapterDiagnostic(const QString& level, const QString& message)
+{
+    if (level == QStringLiteral("debug"))
+    {
+        qCDebug(scopeAdapter) << message;
+    }
+    else if (level == QStringLiteral("info"))
+    {
+        qCInfo(scopeAdapter) << message;
+    }
+    else if (level == QStringLiteral("warning"))
+    {
+        qCWarning(scopeAdapter) << message;
+    }
+    else if (level == QStringLiteral("error"))
+    {
+        qCCritical(scopeAdapter) << message;
+    }
+    else
+    {
+        qCWarning(scopeAdapter) << "AdapterClient: unknown diagnostic level:" << level << "-" << message;
+    }
+}
+
 QStringList ModbusPoll::buildRegisterExpressions(const QList<DataPoint>& registerList)
 {
     QStringList expressions;