Updated trade tracking to post to elasticsearch and switched to using env variables with Infisical

Author: mccaffers

README.md

@@ -87,9 +87,28 @@ Xcode - Library Path
 
 `bash ./scripts/build.sh`
 
+### Environment variables
+
+The engine reads its connection configuration from the environment. The following variables are **required** — `scripts/run.sh` validates them up front and aborts if any are missing or empty:
+
+| Variable | Used for |
+| --- | --- |
+| `ELASTIC_HOST` | Elasticsearch base URL that trading results are PUT to (e.g. `https://elastic.example.com:9200`) |
+| `ELASTIC_USER` | Elasticsearch HTTP basic-auth username |
+| `ELASTIC_USER_PASSWORD` | Elasticsearch HTTP basic-auth password |
+| `REDIS_HOST` | Redis host for the `strategy_queue` list |
+
+I manage these secrets with [Infisical](https://infisical.com/), which injects them into the process environment at runtime, so I run the engine with:
+
+```
+infisical run -- sh ./scripts/run.sh
+```
+
+If you're not using Infisical, export the variables yourself (e.g. via your shell profile or a sourced `.env`) before invoking the script.
+
 ### Run via terminal
 
-`bash ./scripts/run.sh` builds the project, then, if `redis-cli ping` reaches a local Redis, enqueues an inline JSON strategy via `load` and executes it via `run localhost`. If Redis is unreachable the script prints a message and exits cleanly (see `scripts/run.sh:22-25`), so first-time users without Redis still get a clear signal.
+`bash ./scripts/run.sh` builds the project, then, if `redis-cli ping` reaches a local Redis, enqueues an inline JSON strategy via `load` and executes it via `run localhost`. If Redis is unreachable the script prints a message and exits cleanly (see `scripts/run.sh:22-25`), so first-time users without Redis still get a clear signal. The script requires the [environment variables](#environment-variables) listed above; with Infisical that becomes `infisical run -- sh ./scripts/run.sh`.
 
 The `BacktestingEngine` binary exposes a subcommand CLI:
 

include/elasticClient.hpp

@@ -9,8 +9,9 @@
 #include "tradingResults.hpp"
 
 // Minimal Elasticsearch HTTP client — PUT-only, for indexing TradingResults.
-// Host is read from $ELASTICSEARCH_URL (default http://localhost:9200);
-// docs land in index "trading_results" with a freshly generated UUID per put.
+// Host is read from $ELASTIC_HOST (default http://localhost:9200) with optional
+// HTTP basic auth from $ELASTIC_USER / $ELASTIC_USER_PASSWORD; docs land in
+// index "trading_results" with a freshly generated UUID per put.
 class ElasticClient {
 public:
     static int putTradingResults(const TradingResults& results);

include/strategies/strategy.hpp

@@ -11,7 +11,7 @@
 #include "models/trade.hpp"
 
 // Forward declaration. We only refer to `TradeManager` by reference in
-// this header, so the compiler doesn't need its full definition here —
+// this header, so the compiler doesn't need its full definition here,
 // just to know "it's a class". Pulling in the full header would drag
 // every TradeManager dependency into every strategy. C# doesn't really
 // have an equivalent because it resolves types at the assembly level
@@ -25,7 +25,7 @@ class TradeManager;
 //   - This is the C++ equivalent of a C# `interface`. C++ has no
 //     dedicated `interface` keyword, so you express it as a class
 //     whose methods are all pure virtual (the `= 0` suffix). The
-//     `I` prefix is borrowed from C# — C++ has no fixed convention,
+//     `I` prefix is borrowed from C#, C++ has no fixed convention,
 //     but it's a useful hint because C++ classes routinely mix
 //     virtual and concrete methods, so "is this an interface?" isn't
 //     always obvious from the keyword alone.
@@ -34,7 +34,7 @@ class TradeManager;
 //     destructor would skip the derived destructor and leak resources.
 //     C# handles this for you; in C++ you opt in.
 //   - `= 0` makes a method pure virtual, which makes the class
-//     abstract — you cannot instantiate `IStrategy` directly, only
+//     abstract, you cannot instantiate `IStrategy` directly, only
 //     concrete subclasses. Same behaviour as a C# interface.
 //   - Derived classes annotate their implementations with `override`
 //     (see `RandomStrategy`). It's optional in C++ but catches
@@ -52,7 +52,7 @@ class IStrategy {
     // reference so strategies can both inspect open positions
     // (`tradeManager.getActiveTrades()`) and act on them
     // (`closeTrade`, future scale/adjust hooks). A reference signals
-    // "borrow, don't own" — the strategy must not delete it. The C#
+    // "borrow, don't own", the strategy must not delete it. The C#
     // analogue is just passing the manager as a parameter; C# has no
     // distinction between reference and pointer so the by-ref nature
     // is implicit there.

include/trading/reporting.hpp

@@ -6,9 +6,11 @@
 
 #pragma once
 #include "tradeManager.hpp"
+#include "tradingResults.hpp"
 
 class Reporting {
 
 public:
+    static TradingResultsStats collect(const TradeManager& tradeManager);
     static void summarise(const TradeManager& tradeManager);
 };

include/utilities/env.hpp

@@ -0,0 +1,16 @@
+// Backtesting Engine in C++
+//
+// (c) 2026 Ryan McCaffery | https://mccaffers.com
+// This code is licensed under MIT license (see LICENSE.txt for details)
+// ---------------------------------------
+
+#pragma once
+
+#include <string>
+
+namespace env {
+
+// Returns $name, or `fallback` when the variable is unset or empty.
+std::string getOr(const char* name, std::string fallback);
+
+}  // namespace env

scripts/run.sh

@@ -1,6 +1,16 @@
 #!/bin/bash
 # This executes the run script
 
+required_vars=(ELASTIC_HOST ELASTIC_USER ELASTIC_USER_PASSWORD REDIS_HOST)
+missing=()
+for var in "${required_vars[@]}"; do
+    [[ -z "${!var}" ]] && missing+=("$var")
+done
+if [[ ${#missing[@]} -gt 0 ]]; then
+    echo "Error: missing required environment variables: ${missing[*]}"
+    exit 1
+fi
+
 current_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
 # Build the source code
@@ -24,10 +34,6 @@ if ! redis-cli -h localhost ping >/dev/null 2>&1; then
     exit 0
 fi
 
-if ! ./"$BUILD_DIR/$EXECUTABLE_NAME" load; then
-    exit 1
-fi
-
 start_time=$(date +%s%N)
 # Invoke the `run` subcommand: BacktestingEngine pops a Base64-encoded
 # strategy off the Redis `strategy_queue` and executes it against the

source/backtestRunner.cpp

@@ -17,14 +17,17 @@
 
 int runBacktest(const std::string& questdbHost,
                 const trading_definitions::Configuration& config) {
+
   DatabaseConnection db(questdbHost, 8812, "qdb", "admin", "quest");
 
+  // Get a list of symbols
   std::vector<std::string> symbols;
   std::istringstream ss(config.SYMBOLS);
   for (std::string token; std::getline(ss, token, ',');) {
     symbols.push_back(token);
   }
 
+  // Get all the tick data out of QuestDB for these symbols
   std::vector<PriceData> ticks =
       SqlManager::streamPriceData(db, symbols, config.LAST_MONTHS);
 

source/commands/loadCommand.cpp

@@ -9,6 +9,7 @@
 #include <boost/decimal/literals.hpp>
 #include <nlohmann/json.hpp>
 
+#include "env.hpp"
 #include "redisLoader.hpp"
 #include "trading_definitions.hpp"
 
@@ -38,5 +39,5 @@ int LoadCommand::run() {
     };
 
     const nlohmann::json j = config;
-    return RedisLoader::load(j.dump());
+    return RedisLoader::load(j.dump(), env::getOr("REDIS_HOST", "127.0.0.1"));
 }

source/commands/runCommand.cpp

@@ -10,6 +10,7 @@
 #include <string>
 
 #include "backtestRunner.hpp"
+#include "env.hpp"
 #include "jsonParser.hpp"
 #include "redisRunner.hpp"
 
@@ -31,7 +32,7 @@ int RunCommand::run(int argc, const char* argv[]) {
         return 1;
     }
     if (argc == 3) {
-        return RedisRunner::run(argv[2]);
+        return RedisRunner::run(argv[2], env::getOr("REDIS_HOST", "127.0.0.1"));
     }
     return runBacktestFromBase64(argv[2], argv[3]);
 }

source/elasticClient.cpp

@@ -6,7 +6,6 @@
 
 #include "elasticClient.hpp"
 
-#include <cstdlib>
 #include <iostream>
 #include <string>
 
@@ -15,6 +14,8 @@
 #include <boost/uuid/uuid_io.hpp>
 #include <nlohmann/json.hpp>
 
+#include "env.hpp"
+
 namespace {
 
 void ensureCurlInit() {
@@ -25,11 +26,6 @@ void ensureCurlInit() {
     (void)guard;
 }
 
-std::string envOr(const char* name, std::string fallback) {
-    const char* val = std::getenv(name);
-    return val ? std::string{val} : std::move(fallback);
-}
-
 std::string generateUuid() {
     static thread_local boost::uuids::random_generator gen;
     return boost::uuids::to_string(gen());
@@ -40,7 +36,9 @@ std::string generateUuid() {
 int ElasticClient::putTradingResults(const TradingResults& results) {
     ensureCurlInit();
 
-    const std::string host = envOr("ELASTICSEARCH_URL", "http://localhost:9200");
+    const std::string host = env::getOr("ELASTIC_HOST", "http://localhost:9200");
+    const std::string user = env::getOr("ELASTIC_USER", "");
+    const std::string password = env::getOr("ELASTIC_USER_PASSWORD", "");
     const std::string url = host + "/trading_results/_doc/" + generateUuid();
     const std::string body = nlohmann::json(results).dump();
 
@@ -55,6 +53,13 @@ int ElasticClient::putTradingResults(const TradingResults& results) {
 
     curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+
+    // HTTP basic auth when credentials are supplied via the environment.
+    if (!user.empty()) {
+        curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
+        curl_easy_setopt(curl, CURLOPT_USERNAME, user.c_str());
+        curl_easy_setopt(curl, CURLOPT_PASSWORD, password.c_str());
+    }
     curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
     curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body.c_str());
     curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, static_cast<long>(body.size()));