performance/PerformanceTrace.h - GCC Code Coverage Report

Directory:	src/
Coverage:	low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%

	Coverage	Exec / Excl / Total
Lines:	100.0%	4 / 0 / 4
Functions:	100.0%	4 / 0 / 4
Branches:	100.0%	2 / 0 / 2

    performance/PerformanceTrace.h
    
        Line
        Branch
        Exec
        Source
      
        #pragma once
      
        #include <QHash>
      
        #include <QJsonObject>
      
        #include <QMutex>
      
        #include <QObject>
      
        #include <QString>
      
        #include <atomic>
      
        #include <condition_variable>
      
        #include <deque>
      
        #include <memory>
      
        #include <mutex>
      
        #include <thread>
      
        namespace MailJD::Performance {
      
        inline constexpr int TraceSchemaVersion = 1;
      
        enum class Outcome { Success, Failed, Cancelled, Timeout };
      
        struct TraceContext {
      
          QString runId;
      
          QString dataProfile = QStringLiteral("unspecified");
      
          QString cacheState = QStringLiteral("unspecified");
      
          QString networkProfile = QStringLiteral("unspecified");
      
          QString buildSha = QStringLiteral("unknown");
      
          QString buildType = QStringLiteral("unknown");
      
          QString selectedScenario = QStringLiteral("unspecified");
      
        };
      
        class PerformanceTrace;
      
        class Operation {
      
        public:
      
        3427
          Operation() = default;
      
        12370
          Operation(const Operation &) = default;
      
          Operation(Operation &&) noexcept = default;
      
          Operation &operator=(const Operation &) = default;
      
        516
          Operation &operator=(Operation &&) noexcept = default;
      
          ~Operation();
      
          bool isValid() const;
      
          QString id() const;
      
          QString scenario() const;
      
          bool mark(const QString &phase, qint64 itemCount = -1,
      
                    qint64 byteCount = -1) const;
      
          bool startPhase(const QString &phase, qint64 itemCount = -1,
      
                          qint64 byteCount = -1) const;
      
          bool endPhase(const QString &phase, qint64 itemCount = -1,
      
                        qint64 byteCount = -1) const;
      
          bool finish(Outcome outcome, qint64 itemCount = -1,
      
                      qint64 byteCount = -1) const;
      
        private:
      
          struct State {
      
            PerformanceTrace *trace = nullptr;
      
            QString operationId;
      
            QString scenarioName;
      
            QString terminalPhase = QStringLiteral("operation");
      
            qint64 startedNs = 0;
      
            mutable QMutex mutex;
      
            QHash<QString, qint64> openPhases;
      
            std::atomic_bool terminal{false};
      
          };
      
          explicit Operation(std::shared_ptr<State> state);
      
          std::shared_ptr<State> m_state;
      
          friend class PerformanceTrace;
      
        };
      
        class PerformanceTrace {
      
        public:
      
          static PerformanceTrace &instance();
      
          ~PerformanceTrace();
      
          PerformanceTrace(const PerformanceTrace &) = delete;
      
          PerformanceTrace &operator=(const PerformanceTrace &) = delete;
      
          static qint64 monotonicNowNs();
      
          static QString outcomeName(Outcome outcome);
      
          static bool isSafeToken(const QString &value);
      
          bool configure(const QString &path, const TraceContext &context,
      
                         QString *error = nullptr);
      
          void shutdown();
      
          bool isEnabled() const;
      
          QString outputPath() const;
      
          QString lastError() const;
      
          QString selectedScenario() const;
      
          Operation startOperation(const QString &scenario, qint64 itemCount = -1,
      
                                   qint64 byteCount = -1,
      
                                   qint64 startNs = -1);
      
          Operation startMetric(const QString &scenario, const QString &metric,
      
                                qint64 startNs = -1, qint64 itemCount = -1,
      
                                qint64 byteCount = -1);
      
          bool markProcessEvent(const QString &scenario, const QString &phase,
      
                                qint64 timestampNs = -1, qint64 durationNs = 0,
      
                                qint64 itemCount = -1, qint64 byteCount = -1);
      
          void startEventLoopHeartbeat(QObject *owner, int intervalMs = 50);
      
        private:
      
          2/2✓ Branch 4 → 5 taken 44 times.
✓ Branch 8 → 9 taken 44 times.

        44
          PerformanceTrace() = default;
      
          bool validateContext(const TraceContext &context, QString *error) const;
      
          void enqueue(const QJsonObject &record);
      
          QJsonObject baseRecord(const QString &operationId, const QString &scenario,
      
                                 const QString &phase, const QString &event,
      
                                 qint64 timestampNs, qint64 durationNs,
      
                                 const QString &outcome, qint64 itemCount,
      
                                 qint64 byteCount) const;
      
          void writerLoop();
      
          mutable std::mutex m_mutex;
      
          std::condition_variable m_condition;
      
          std::deque<QJsonObject> m_queue;
      
          std::thread m_writer;
      
          bool m_enabled = false;
      
          bool m_stopping = false;
      
          QString m_path;
      
          QString m_error;
      
          TraceContext m_context;
      
          std::atomic<quint64> m_nextOperation{1};
      
          friend class Operation;
      
        };
      
        } // namespace MailJD::Performance

Line	Branch	Exec	Source
1			#pragma once
2
3			#include <QHash>
4			#include <QJsonObject>
5			#include <QMutex>
6			#include <QObject>
7			#include <QString>
8
9			#include <atomic>
10			#include <condition_variable>
11			#include <deque>
12			#include <memory>
13			#include <mutex>
14			#include <thread>
15
16			namespace MailJD::Performance {
17
18			inline constexpr int TraceSchemaVersion = 1;
19
20			enum class Outcome { Success, Failed, Cancelled, Timeout };
21
22			struct TraceContext {
23			QString runId;
24			QString dataProfile = QStringLiteral("unspecified");
25			QString cacheState = QStringLiteral("unspecified");
26			QString networkProfile = QStringLiteral("unspecified");
27			QString buildSha = QStringLiteral("unknown");
28			QString buildType = QStringLiteral("unknown");
29			QString selectedScenario = QStringLiteral("unspecified");
30			};
31
32			class PerformanceTrace;
33
34			class Operation {
35			public:
36		3427	Operation() = default;
37		12370	Operation(const Operation &) = default;
38			Operation(Operation &&) noexcept = default;
39			Operation &operator=(const Operation &) = default;
40		516	Operation &operator=(Operation &&) noexcept = default;
41			~Operation();
42
43			bool isValid() const;
44			QString id() const;
45			QString scenario() const;
46
47			bool mark(const QString &phase, qint64 itemCount = -1,
48			qint64 byteCount = -1) const;
49			bool startPhase(const QString &phase, qint64 itemCount = -1,
50			qint64 byteCount = -1) const;
51			bool endPhase(const QString &phase, qint64 itemCount = -1,
52			qint64 byteCount = -1) const;
53			bool finish(Outcome outcome, qint64 itemCount = -1,
54			qint64 byteCount = -1) const;
55
56			private:
57			struct State {
58			PerformanceTrace *trace = nullptr;
59			QString operationId;
60			QString scenarioName;
61			QString terminalPhase = QStringLiteral("operation");
62			qint64 startedNs = 0;
63			mutable QMutex mutex;
64			QHash<QString, qint64> openPhases;
65			std::atomic_bool terminal{false};
66			};
67
68			explicit Operation(std::shared_ptr<State> state);
69			std::shared_ptr<State> m_state;
70
71			friend class PerformanceTrace;
72			};
73
74			class PerformanceTrace {
75			public:
76			static PerformanceTrace &instance();
77			~PerformanceTrace();
78
79			PerformanceTrace(const PerformanceTrace &) = delete;
80			PerformanceTrace &operator=(const PerformanceTrace &) = delete;
81
82			static qint64 monotonicNowNs();
83			static QString outcomeName(Outcome outcome);
84			static bool isSafeToken(const QString &value);
85
86			bool configure(const QString &path, const TraceContext &context,
87			QString *error = nullptr);
88			void shutdown();
89			bool isEnabled() const;
90			QString outputPath() const;
91			QString lastError() const;
92			QString selectedScenario() const;
93
94			Operation startOperation(const QString &scenario, qint64 itemCount = -1,
95			qint64 byteCount = -1,
96			qint64 startNs = -1);
97			Operation startMetric(const QString &scenario, const QString &metric,
98			qint64 startNs = -1, qint64 itemCount = -1,
99			qint64 byteCount = -1);
100			bool markProcessEvent(const QString &scenario, const QString &phase,
101			qint64 timestampNs = -1, qint64 durationNs = 0,
102			qint64 itemCount = -1, qint64 byteCount = -1);
103
104			void startEventLoopHeartbeat(QObject *owner, int intervalMs = 50);
105
106			private:
107	2/2 ✓ Branch 4 → 5 taken 44 times. ✓ Branch 8 → 9 taken 44 times.	44	PerformanceTrace() = default;
108
109			bool validateContext(const TraceContext &context, QString *error) const;
110			void enqueue(const QJsonObject &record);
111			QJsonObject baseRecord(const QString &operationId, const QString &scenario,
112			const QString &phase, const QString &event,
113			qint64 timestampNs, qint64 durationNs,
114			const QString &outcome, qint64 itemCount,
115			qint64 byteCount) const;
116			void writerLoop();
117
118			mutable std::mutex m_mutex;
119			std::condition_variable m_condition;
120			std::deque<QJsonObject> m_queue;
121			std::thread m_writer;
122			bool m_enabled = false;
123			bool m_stopping = false;
124			QString m_path;
125			QString m_error;
126			TraceContext m_context;
127			std::atomic<quint64> m_nextOperation{1};
128
129			friend class Operation;
130			};
131
132			} // namespace MailJD::Performance
133