FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
// LatencyTracker — per-order latency monitoring (in-memory v1).
//
// TODO(persistence): mirror OpenAlgo's latency_db and persist completed
// OrderLatency records to SQLite (keep ORDER-type logs forever, auto-purge
// DATA-type logs after N days). For this pass we keep a bounded in-memory ring
// which is sufficient for live stats/reporting without DB I/O on the hot path.
#include "trading/LatencyTracker.h"
#include "core/logging/Logger.h"
#include <QMutexLocker>
#include <algorithm>
#include <cmath>
namespace fincept::trading {
LatencyTracker& LatencyTracker::instance() {
static LatencyTracker s;
return s;
}
void LatencyTracker::begin(const QString& tracking_id) {
QMutexLocker lock(&mutex_);
InFlight f;
f.total.start();
f.stage.start();
in_flight_.insert(tracking_id, f);
}
void LatencyTracker::mark_validation_done(const QString& tracking_id) {
QMutexLocker lock(&mutex_);
auto it = in_flight_.find(tracking_id);
if (it == in_flight_.end())
return;
// restart() returns elapsed-since-last-restart in ms and resets the timer.
it->validation_ms = static_cast<double>(it->stage.restart());
}
void LatencyTracker::mark_broker_request_sent(const QString& tracking_id) {
QMutexLocker lock(&mutex_);
auto it = in_flight_.find(tracking_id);
if (it == in_flight_.end())
return;
// Marks the start of the broker call — discard any time between validation
// and the request actually firing.
it->stage.restart();
}
void LatencyTracker::mark_broker_response_received(const QString& tracking_id) {
QMutexLocker lock(&mutex_);
auto it = in_flight_.find(tracking_id);
if (it == in_flight_.end())
return;
it->broker_rtt_ms = static_cast<double>(it->stage.restart());
}
void LatencyTracker::mark_complete(const QString& tracking_id, const QString& order_id, const QString& account_id,
const QString& broker, const QString& symbol, const QString& order_type,
const QString& status, const QString& error) {
QMutexLocker lock(&mutex_);
auto it = in_flight_.find(tracking_id);
if (it == in_flight_.end()) {
LOG_WARN("LatencyTracker", QString("mark_complete for unknown tracking_id: %1").arg(tracking_id));
return;
}
OrderLatency entry;
entry.order_id = order_id;
entry.account_id = account_id;
entry.broker = broker;
entry.symbol = symbol;
entry.order_type = order_type;
entry.validation_ms = it->validation_ms;
entry.broker_rtt_ms = it->broker_rtt_ms;
entry.response_ms = static_cast<double>(it->stage.elapsed()); // since broker response received
entry.total_ms = static_cast<double>(it->total.elapsed());
entry.status = status;
entry.error = error;
entry.timestamp = QDateTime::currentDateTime();
in_flight_.erase(it);
history_.append(entry);
while (history_.size() > kMaxHistory)
history_.removeFirst();
}
QVector<LatencyTracker::OrderLatency> LatencyTracker::get_history(const QString& account_id, int limit) const {
QMutexLocker lock(&mutex_);
QVector<OrderLatency> out;
if (limit <= 0)
return out;
// Walk newest-first, collect up to `limit` matches, then restore chronological order.
for (int i = history_.size() - 1; i >= 0 && out.size() < limit; --i) {
const OrderLatency& e = history_.at(i);
if (!account_id.isEmpty() && e.account_id != account_id)
continue;
out.append(e);
}
std::reverse(out.begin(), out.end());
return out;
}
LatencyTracker::LatencyStats LatencyTracker::get_stats(const QString& broker, int last_n_hours) const {
QMutexLocker lock(&mutex_);
LatencyStats stats;
const QDateTime cutoff =
(last_n_hours > 0) ? QDateTime::currentDateTime().addSecs(-qint64(last_n_hours) * 3600) : QDateTime();
QVector<double> rtts;
double sum_rtt = 0;
double sum_total = 0;
for (const OrderLatency& e : history_) {
if (!broker.isEmpty() && e.broker != broker)
continue;
if (cutoff.isValid() && e.timestamp < cutoff)
continue;
++stats.total_orders;
if (e.status == QStringLiteral("FAILED"))
++stats.failed_orders;
rtts.append(e.broker_rtt_ms);
sum_rtt += e.broker_rtt_ms;
sum_total += e.total_ms;
}
if (stats.total_orders == 0)
return stats;
stats.avg_rtt_ms = sum_rtt / stats.total_orders;
stats.avg_total_ms = sum_total / stats.total_orders;
std::sort(rtts.begin(), rtts.end());
auto percentile = [&rtts](double p) -> double {
if (rtts.isEmpty())
return 0;
// Nearest-rank percentile on the sorted copy.
int idx = static_cast<int>(std::ceil(p / 100.0 * rtts.size())) - 1;
if (idx < 0)
idx = 0;
if (idx >= rtts.size())
idx = rtts.size() - 1;
return rtts.at(idx);
};
stats.p50_rtt_ms = percentile(50);
stats.p95_rtt_ms = percentile(95);
stats.p99_rtt_ms = percentile(99);
return stats;
}
} // namespace fincept::trading