| #include "RuntimeStorage.mqh"
|
| //+------------------------------------------------------------------+
|
| //| UnifiedTradeLogger.mqh |
|
| //| Purpose: Comprehensive JSON logging for complete trade lifecycle |
|
| //| Features: Execution + Close logging with gate journey details |
|
| //+------------------------------------------------------------------+
|
| #ifndef __UNIFIEDTRADELOGGER_MQH__
|
| #define __UNIFIEDTRADELOGGER_MQH__
|
|
|
| #include "AdaptiveSignalOptimizer.mqh"
|
| #include <Files/File.mqh>
|
|
|
| // Complete trade record
|
| struct UnifiedTradeRecord
|
| {
|
| // Trade identification
|
| string trade_id;
|
| string signal_id;
|
| datetime execution_time;
|
| datetime close_time;
|
|
|
| // Strategy and market
|
| string strategy_name;
|
| string symbol;
|
| int timeframe;
|
| string market_regime;
|
| double volatility;
|
|
|
| // Execution details
|
| double entry_price;
|
| double exit_price;
|
| double sl;
|
| double tp;
|
| double volume;
|
| int order_type;
|
|
|
| // Gate journey
|
| GateJourneyStep gate_journey[24];
|
| int journey_length;
|
|
|
| // Optimization details
|
| bool was_adjusted;
|
| int adjustment_attempts;
|
| int blocking_gate; // Which gate initially blocked (-1 if none)
|
|
|
| // Outcome
|
| bool is_closed;
|
| bool was_winner;
|
| double profit_pct;
|
| double profit_absolute;
|
| double hold_duration_minutes;
|
|
|
| // Learning metadata
|
| double confidence;
|
| string close_reason; // "profit_target", "stop_loss", "signal_reversal", etc.
|
|
|
| // Position reviews
|
| int reviews_performed;
|
| string review_actions[]; // "HOLD", "ADJUST_SL", etc.
|
|
|
| // Execution callers populate only the fields they have. In particular,
|
| // an untouched journey length must never be interpreted as an array bound.
|
| UnifiedTradeRecord()
|
| {
|
| execution_time = 0;
|
| close_time = 0;
|
| timeframe = 0;
|
| volatility = 0.0;
|
| entry_price = 0.0;
|
| exit_price = 0.0;
|
| sl = 0.0;
|
| tp = 0.0;
|
| volume = 0.0;
|
| order_type = 0;
|
| journey_length = 0;
|
| was_adjusted = false;
|
| adjustment_attempts = 0;
|
| blocking_gate = -1;
|
| is_closed = false;
|
| was_winner = false;
|
| profit_pct = 0.0;
|
| profit_absolute = 0.0;
|
| hold_duration_minutes = 0.0;
|
| confidence = 0.0;
|
| reviews_performed = 0;
|
| ZeroMemory(gate_journey);
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Unified Trade Logger - Complete lifecycle tracking |
|
| //+------------------------------------------------------------------+
|
| class CUnifiedTradeLogger
|
| {
|
| private:
|
| string m_log_directory;
|
| string m_daily_log_file;
|
| datetime m_current_day;
|
|
|
| int m_trades_logged;
|
| int m_trades_closed;
|
|
|
| string EscapeJSON(string value)
|
| {
|
| string escaped = "";
|
| for(int i=0; i<StringLen(value); i++)
|
| {
|
| ushort ch = StringGetCharacter(value, i);
|
| if(ch == 92) escaped += "\\\\";
|
| else if(ch == 34) escaped += "\\\"";
|
| else if(ch == 13) escaped += "\\r";
|
| else if(ch == 10) escaped += "\\n";
|
| else if(ch == 9) escaped += "\\t";
|
| else if(ch < 32) escaped += StringFormat("\\u%04x", (int)ch);
|
| else escaped += StringSubstr(value, i, 1);
|
| }
|
| return escaped;
|
| }
|
|
|
| bool IsJSONSpace(ushort ch)
|
| {
|
| return ch == 32 || ch == 9 || ch == 10 || ch == 13;
|
| }
|
|
|
| // Extract complete trade objects without treating braces in strings as
|
| // structure. Never overwrite an existing log that cannot be read safely.
|
| bool ReadTrades(string &trades[])
|
| {
|
| ArrayResize(trades, 0);
|
| if(!FileIsExist(m_daily_log_file, DUALEA_FILE_COMMON)) return true;
|
| int handle = FileOpen(m_daily_log_file, FILE_READ|FILE_TXT|DUALEA_FILE_COMMON|FILE_ANSI|FILE_SHARE_READ, 0, CP_UTF8);
|
| if(handle == INVALID_HANDLE) return false;
|
| string document = "";
|
| while(!FileIsEnding(handle)) document += FileReadString(handle) + "\n";
|
| FileClose(handle);
|
| string trimmed = document;
|
| StringTrimLeft(trimmed);
|
| StringTrimRight(trimmed);
|
| if(trimmed == "") return true;
|
| int key = StringFind(document, "\"trades\"");
|
| if(key < 0) return false;
|
| int begin = StringFind(document, "[", key + 8);
|
| if(begin < 0) return false;
|
| bool quoted = false, escaped = false, need_comma = false;
|
| int depth = 0, start = -1;
|
| for(int i=begin+1; i<StringLen(document); i++)
|
| {
|
| ushort ch = StringGetCharacter(document, i);
|
| if(quoted)
|
| {
|
| if(escaped) escaped = false;
|
| else if(ch == 92) escaped = true;
|
| else if(ch == 34) quoted = false;
|
| continue;
|
| }
|
| if(depth > 0)
|
| {
|
| if(ch == 34) quoted = true;
|
| else if(ch == 123) depth++;
|
| else if(ch == 125)
|
| {
|
| depth--;
|
| if(depth == 0)
|
| {
|
| int count = ArraySize(trades);
|
| if(ArrayResize(trades, count+1) != count+1) return false;
|
| trades[count] = StringSubstr(document, start, i-start+1);
|
| need_comma = true;
|
| }
|
| }
|
| continue;
|
| }
|
| if(IsJSONSpace(ch)) continue;
|
| if(ch == 93)
|
| {
|
| // A comma must be followed by another object, not the array end.
|
| if(!need_comma && ArraySize(trades) > 0) return false;
|
| string suffix = StringSubstr(document, i+1);
|
| StringTrimLeft(suffix);
|
| StringTrimRight(suffix);
|
| return suffix == "}";
|
| }
|
| if(need_comma)
|
| {
|
| if(ch != 44) return false;
|
| need_comma = false;
|
| continue;
|
| }
|
| if(ch != 123) return false;
|
| start = i;
|
| depth = 1;
|
| }
|
| return false;
|
| }
|
|
|
| bool MatchesTradeId(const string trade, const string trade_id)
|
| {
|
| int key = StringFind(trade, "\"trade_id\"");
|
| if(key < 0) return false;
|
| int pos = key + 10;
|
| int length = StringLen(trade);
|
| while(pos < length && IsJSONSpace(StringGetCharacter(trade, pos))) pos++;
|
| if(pos >= length || StringGetCharacter(trade, pos++) != 58) return false;
|
| while(pos < length && IsJSONSpace(StringGetCharacter(trade, pos))) pos++;
|
| if(pos >= length || StringGetCharacter(trade, pos++) != 34) return false;
|
| int start = pos;
|
| bool escaped = false;
|
| for(; pos<length; pos++)
|
| {
|
| ushort ch = StringGetCharacter(trade, pos);
|
| if(escaped) escaped = false;
|
| else if(ch == 92) escaped = true;
|
| else if(ch == 34) return StringSubstr(trade, start, pos-start) == EscapeJSON(trade_id);
|
| }
|
| return false;
|
| }
|
|
|
| bool WriteTrades(const string &trades[], datetime log_date=0)
|
| {
|
| string document = "{\n";
|
| document += StringFormat(" \"date\": \"%s\",\n", TimeToString(log_date > 0 ? log_date : TimeCurrent(), TIME_DATE));
|
| document += " \"trades\": [\n";
|
| for(int i=0; i<ArraySize(trades); i++)
|
| {
|
| if(i > 0) document += ",\n";
|
| document += trades[i];
|
| }
|
| document += "\n ]\n}\n";
|
| string temporary = m_daily_log_file + ".tmp";
|
| uchar bytes[];
|
| int length = StringToCharArray(document, bytes, 0, WHOLE_ARRAY, CP_UTF8) - 1;
|
| if(length <= 0) return false;
|
| int handle = FileOpen(temporary, FILE_WRITE|FILE_BIN|DUALEA_FILE_COMMON);
|
| if(handle == INVALID_HANDLE) return false;
|
| uint written = FileWriteArray(handle, bytes, 0, length);
|
| FileFlush(handle);
|
| FileClose(handle);
|
| if(written != (uint)length || !FileMove(temporary, DUALEA_FILE_COMMON, m_daily_log_file, DUALEA_FILE_COMMON|FILE_REWRITE))
|
| {
|
| FileDelete(temporary, DUALEA_FILE_COMMON);
|
| return false;
|
| }
|
| return true;
|
| }
|
|
|
| // Get current day's log file
|
| string GetDailyLogFile()
|
| {
|
| MqlDateTime dt;
|
| TimeToStruct(TimeCurrent(), dt);
|
|
|
| string date_str = StringFormat("%04d%02d%02d", dt.year, dt.mon, dt.day);
|
| return m_log_directory + "\\" + "trades_" + date_str + ".json";
|
| }
|
|
|
| // Check if day changed
|
| bool CheckDayChange()
|
| {
|
| MqlDateTime dt;
|
| TimeToStruct(TimeCurrent(), dt);
|
| datetime today = StringToTime(StringFormat("%04d.%02d.%02d", dt.year, dt.mon, dt.day));
|
|
|
| if(today != m_current_day)
|
| {
|
| m_current_day = today;
|
| m_daily_log_file = GetDailyLogFile();
|
| return true;
|
| }
|
| return false;
|
| }
|
|
|
| public:
|
| CUnifiedTradeLogger(string directory="DualEA\\trade_logs")
|
| {
|
| m_log_directory = directory;
|
| FolderCreate("DualEA", DUALEA_FILE_COMMON);
|
| FolderCreate(m_log_directory, DUALEA_FILE_COMMON);
|
| m_current_day = 0;
|
| m_trades_logged = 0;
|
| m_trades_closed = 0;
|
|
|
| CheckDayChange();
|
|
|
| PrintFormat("📝 UnifiedTradeLogger initialized: %s", m_daily_log_file);
|
| }
|
|
|
| // Log trade at execution (preliminary record). Every successful write is
|
| // a complete JSON document; no fixed-offset tail overwrites are used.
|
| void LogTradeExecution(const UnifiedTradeRecord &record)
|
| {
|
| CheckDayChange();
|
| string trades[];
|
| if(!ReadTrades(trades))
|
| {
|
| Print("[TradeLogger] Existing log is unreadable or malformed; preserving it: ", m_daily_log_file);
|
| return;
|
| }
|
| int count = ArraySize(trades);
|
| if(ArrayResize(trades, count+1) != count+1) return;
|
| trades[count] = FormatTradeAsJSON(record, false);
|
| if(!WriteTrades(trades))
|
| {
|
| Print("[TradeLogger] Could not commit execution record: ", EscapeJSON(record.trade_id));
|
| return;
|
| }
|
| m_trades_logged++;
|
| PrintFormat("[TradeLogger] Execution logged: %s (Total: %d)", record.trade_id, m_trades_logged);
|
| }
|
|
|
| // Locate the execution-day file so a close after midnight updates the
|
| // original trade instead of searching only today's file.
|
| void LogTradeClose(const UnifiedTradeRecord &record)
|
| {
|
| CheckDayChange();
|
| string current_file = m_daily_log_file;
|
| if(record.execution_time > 0)
|
| {
|
| MqlDateTime dt;
|
| TimeToStruct(record.execution_time, dt);
|
| m_daily_log_file = m_log_directory + "\\trades_" + StringFormat("%04d%02d%02d", dt.year, dt.mon, dt.day) + ".json";
|
| }
|
| string trades[];
|
| bool committed = false;
|
| if(ReadTrades(trades))
|
| {
|
| for(int i=0; i<ArraySize(trades); i++)
|
| {
|
| if(!MatchesTradeId(trades[i], record.trade_id)) continue;
|
| trades[i] = FormatTradeAsJSON(record, true);
|
| committed = WriteTrades(trades, record.execution_time);
|
| break;
|
| }
|
| }
|
| m_daily_log_file = current_file;
|
| if(!committed)
|
| {
|
| Print("[TradeLogger] Close record not committed: ", EscapeJSON(record.trade_id));
|
| return;
|
| }
|
| m_trades_closed++;
|
| PrintFormat("[TradeLogger] Close logged: %s | PnL: %+.2f%% | Duration: %.1f min",
|
| record.trade_id, record.profit_pct, record.hold_duration_minutes);
|
| }
|
|
|
| // Format trade as JSON
|
| string FormatTradeAsJSON(const UnifiedTradeRecord &record, bool is_final)
|
| {
|
| string json = " {\n";
|
|
|
| // Basic info
|
| json += StringFormat(" \"trade_id\": \"%s\",\n", EscapeJSON(record.trade_id));
|
| json += StringFormat(" \"signal_id\": \"%s\",\n", EscapeJSON(record.signal_id));
|
| json += StringFormat(" \"execution_time\": \"%s\",\n", TimeToString(record.execution_time));
|
| json += StringFormat(" \"status\": \"%s\",\n", is_final ? "closed" : "open");
|
|
|
| // Strategy and market
|
| json += StringFormat(" \"strategy\": \"%s\",\n", EscapeJSON(record.strategy_name));
|
| json += StringFormat(" \"symbol\": \"%s\",\n", EscapeJSON(record.symbol));
|
| json += StringFormat(" \"timeframe\": %d,\n", record.timeframe);
|
| json += StringFormat(" \"market_regime\": \"%s\",\n", EscapeJSON(record.market_regime));
|
| json += StringFormat(" \"volatility\": %.4f,\n", record.volatility);
|
|
|
| // Execution details
|
| json += " \"execution\": {\n";
|
| json += StringFormat(" \"entry_price\": %.5f,\n", record.entry_price);
|
| json += StringFormat(" \"sl\": %.5f,\n", record.sl);
|
| json += StringFormat(" \"tp\": %.5f,\n", record.tp);
|
| json += StringFormat(" \"volume\": %.2f,\n", record.volume);
|
| json += StringFormat(" \"order_type\": %d,\n", record.order_type);
|
| json += StringFormat(" \"confidence\": %.3f\n", record.confidence);
|
| json += " },\n";
|
|
|
| // Gate journey
|
| json += " \"gate_journey\": [\n";
|
| // Persisted or caller-supplied lengths may be invalid even when new
|
| // records are initialized correctly. Bound every access to capacity.
|
| int journey_count = MathMax(0, MathMin(record.journey_length, ArraySize(record.gate_journey)));
|
| for(int i = 0; i < journey_count; i++)
|
| {
|
| GateJourneyStep step = record.gate_journey[i];
|
|
|
| if(i > 0) json += ",\n";
|
|
|
| json += " {\n";
|
| json += StringFormat(" \"gate\": \"%s\",\n", EscapeJSON(step.gate_name));
|
| json += StringFormat(" \"index\": %d,\n", step.gate_index);
|
| json += StringFormat(" \"passed\": %s,\n", step.passed ? "true" : "false");
|
| json += StringFormat(" \"reason\": \"%s\",\n", EscapeJSON(step.reason));
|
| json += StringFormat(" \"adjusted\": %s", step.was_adjusted ? "true" : "false");
|
|
|
| if(step.was_adjusted)
|
| {
|
| json += ",\n \"adjustments\": {\n";
|
| json += StringFormat(" \"price\": [%.5f, %.5f],\n", step.price_before, step.price_after);
|
| json += StringFormat(" \"sl\": [%.5f, %.5f],\n", step.sl_before, step.sl_after);
|
| json += StringFormat(" \"tp\": [%.5f, %.5f],\n", step.tp_before, step.tp_after);
|
| json += StringFormat(" \"volume\": [%.2f, %.2f]\n", step.volume_before, step.volume_after);
|
| json += " }\n";
|
| }
|
| else
|
| {
|
| json += "\n";
|
| }
|
|
|
| json += " }";
|
| }
|
| json += "\n ],\n";
|
|
|
| // Optimization info
|
| json += " \"optimization\": {\n";
|
| json += StringFormat(" \"was_adjusted\": %s,\n", record.was_adjusted ? "true" : "false");
|
| json += StringFormat(" \"attempts\": %d,\n", record.adjustment_attempts);
|
| json += StringFormat(" \"blocking_gate\": %d\n", record.blocking_gate);
|
| json += " }";
|
|
|
| // Final outcome (if closed)
|
| if(is_final)
|
| {
|
| json += ",\n \"outcome\": {\n";
|
| json += StringFormat(" \"close_time\": \"%s\",\n", TimeToString(record.close_time));
|
| json += StringFormat(" \"exit_price\": %.5f,\n", record.exit_price);
|
| json += StringFormat(" \"profit_pct\": %.2f,\n", record.profit_pct);
|
| json += StringFormat(" \"profit_absolute\": %.2f,\n", record.profit_absolute);
|
| json += StringFormat(" \"duration_minutes\": %.1f,\n", record.hold_duration_minutes);
|
| json += StringFormat(" \"was_winner\": %s,\n", record.was_winner ? "true" : "false");
|
| json += StringFormat(" \"close_reason\": \"%s\",\n", EscapeJSON(record.close_reason));
|
| json += StringFormat(" \"reviews_performed\": %d\n", record.reviews_performed);
|
| json += " }";
|
| }
|
|
|
| json += "\n }";
|
|
|
| return json;
|
| }
|
|
|
| // Get statistics
|
| void GetStatistics(int &total_logged, int &total_closed)
|
| {
|
| total_logged = m_trades_logged;
|
| total_closed = m_trades_closed;
|
| }
|
|
|
| void PrintReport()
|
| {
|
| PrintFormat("\n📝 === Unified Trade Logger Report ===");
|
| PrintFormat("Trades Logged: %d", m_trades_logged);
|
| PrintFormat("Trades Closed: %d", m_trades_closed);
|
| PrintFormat("Current Log File: %s", m_daily_log_file);
|
| PrintFormat("=====================================\n");
|
| }
|
| };
|
|
|
| #endif
|
