forex-scalping.com

Code: Select all

//+------------------------------------------------------------------+
//|                               Background_Execution_Logger.mq5    |
//+------------------------------------------------------------------+
#property copyright "Execution Logger"
#property version   "1.10"

input string InpFileName = "Liquidity_Sweeps_Log.csv"; 

int fileHandle = INVALID_HANDLE;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    // Open file in common folder so it's easily accessible and shared
    // FILE_COMMON saves to: %APPDATA%\MetaQuotes\Terminal\Common\Files
    fileHandle = FileOpen(InpFileName, FILE_READ | FILE_WRITE | FILE_CSV | FILE_ANSI | FILE_COMMON, ',');
    
    if(fileHandle != INVALID_HANDLE)
    {
        if(FileSize(fileHandle) == 0)
        {
            // Write headers if file is new
            FileWrite(fileHandle, "GMT_Time", "Local_Ms_Tick", "Symbol", "Action", "Requested_Price", "Fill_Price", "Slippage_Points", "Volume", "Deal_Ticket");
        }
        // Move pointer to the end of the file for rolling append
        FileSeek(fileHandle, 0, SEEK_END);
        Print("Background Execution Logger Initialized. Writing to Common/Files/", InpFileName);
    }
    else
    {
        Print("Error opening file: ", GetLastError());
        return(INIT_FAILED);
    }
    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    if(fileHandle != INVALID_HANDLE)
    {
        FileClose(fileHandle);
        Print("Execution Logger file closed.");
    }
}

//+------------------------------------------------------------------+
//| TradeTransaction function                                        |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
{
    if(trans.type != TRADE_TRANSACTION_DEAL_ADD)
        return;

    ulong dealTicket = trans.deal;
    
    if(HistoryDealSelect(dealTicket))
    {
        ulong orderTicket = HistoryDealGetInteger(dealTicket, DEAL_ORDER);
        
        if(HistoryOrderSelect(orderTicket))
        {
            string symbol = HistoryDealGetString(dealTicket, DEAL_SYMBOL);
            double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
            if(point == 0) return; 
            
            ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)HistoryOrderGetInteger(orderTicket, ORDER_TYPE);
            long orderReason = HistoryOrderGetInteger(orderTicket, ORDER_REASON);
            
            double requestedPrice = HistoryOrderGetDouble(orderTicket, ORDER_PRICE_OPEN);
            double fillPrice = HistoryDealGetDouble(dealTicket, DEAL_PRICE);
            double volume = HistoryDealGetDouble(dealTicket, DEAL_VOLUME);
            
            double slippagePoints = 0;

            if(orderType == ORDER_TYPE_BUY || orderType == ORDER_TYPE_BUY_STOP || orderType == ORDER_TYPE_BUY_LIMIT || orderType == ORDER_TYPE_BUY_STOP_LIMIT)
            {
                slippagePoints = (fillPrice - requestedPrice) / point;
            }
            else if(orderType == ORDER_TYPE_SELL || orderType == ORDER_TYPE_SELL_STOP || orderType == ORDER_TYPE_SELL_LIMIT || orderType == ORDER_TYPE_SELL_STOP_LIMIT)
            {
                slippagePoints = (requestedPrice - fillPrice) / point;
            }
            
            string orderTypeStr = EnumToString(orderType);
            if(orderReason == ORDER_REASON_SL) orderTypeStr = "STOP_LOSS";
            else if(orderReason == ORDER_REASON_TP) orderTypeStr = "TAKE_PROFIT";
            
            // Format timestamp for London hour alignment (GMT baseline)
            datetime timeGMT = TimeGMT();
            string timeStr = TimeToString(timeGMT, TIME_DATE | TIME_SECONDS);
            ulong localMs = GetMicrosecondCount() / 1000; // Track millisecond pacing
            
            // Append row to CSV
            if(fileHandle != INVALID_HANDLE)
            {
                FileWrite(fileHandle, timeStr, localMs, symbol, orderTypeStr, requestedPrice, fillPrice, slippagePoints, volume, dealTicket);
                
                // Force write to disk immediately. Prevents data loss if the terminal crashes 
                // or connection is lost during high-frequency liquidity events.
                FileFlush(fileHandle); 
            }
            
            PrintFormat("LOGGED -> %s | Vol: %.2f | Slippage: %.1f pts", symbol, volume, slippagePoints);
        }
    }
}

Code: Select all

using System;
using System.IO;
using System.Linq;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FileSystem)]
    public class BackgroundExecutionLogger : Robot
    {
        [Parameter("Log File Name", DefaultValue = "cTrader_Liquidity_Sweeps.csv")]
        public string FileName { get; set; }

        private string _filePath;
        private readonly object _fileLock = new object();

        protected override void OnStart()
        {
            // cTrader sandboxes file I/O unless explicitly directed to a safe zone.
            // This saves the log to: Documents\cAlgo\ExecutionLogs\
            string directory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "cAlgo", "ExecutionLogs");
            Directory.CreateDirectory(directory);
            _filePath = Path.Combine(directory, FileName);

            lock (_fileLock)
            {
                if (!File.Exists(_filePath))
                {
                    File.WriteAllText(_filePath, "GMT_Time,Local_Ms,Symbol,Action,Requested_Price,Fill_Price,Slippage_Points,Volume,Position_ID\n");
                }
            }

            // Hook into execution events
            PendingOrders.Filled += OnPendingOrderFilled;
            Positions.Closed += OnPositionClosed;

            Print($"Execution Logger running. Saving to: {_filePath}");
        }

        private void OnPendingOrderFilled(PendingOrderFilledEventArgs args)
        {
            var pendingOrder = args.PendingOrder;
            var position = args.Position;
            var symbol = Symbols.GetSymbol(position.SymbolName);

            double requestedPrice = pendingOrder.TargetPrice;
            double fillPrice = position.EntryPrice;
            double volume = position.VolumeInUnits;
            
            double slippagePoints = 0;
            string action = pendingOrder.OrderType.ToString().ToUpper();

            // Calculate slippage using TickSize (cTrader's equivalent to MT5 Point)
            // Positive = Cost to trader / Negative = Price improvement
            if (pendingOrder.TradeType == TradeType.Buy)
            {
                slippagePoints = (fillPrice - requestedPrice) / symbol.TickSize;
            }
            else
            {
                slippagePoints = (requestedPrice - fillPrice) / symbol.TickSize;
            }

            LogExecution(symbol.Name, action, requestedPrice, fillPrice, slippagePoints, volume, position.Id);
        }

        private void OnPositionClosed(PositionClosedEventArgs args)
        {
            var position = args.Position;
            var symbol = Symbols.GetSymbol(position.SymbolName);
            
            // Fetch exact closing execution price from history
            var historyItem = History.FirstOrDefault(x => x.PositionId == position.Id);
            if (historyItem == null) return;

            double fillPrice = historyItem.ClosingPrice;
            double requestedPrice = 0;
            string action = "";

            if (args.Reason == PositionCloseReason.StopLoss && position.StopLoss.HasValue)
            {
                requestedPrice = position.StopLoss.Value;
                action = "STOP_LOSS";
            }
            else if (args.Reason == PositionCloseReason.TakeProfit && position.TakeProfit.HasValue)
            {
                requestedPrice = position.TakeProfit.Value;
                action = "TAKE_PROFIT";
            }
            else
            {
                return; // We only want to log structural sweeps against SL/TP
            }

            double slippagePoints = 0;
            
            // Reverse slippage logic for exits (Buy position closes via Sell execution)
            if (position.TradeType == TradeType.Buy)
            {
                slippagePoints = (requestedPrice - fillPrice) / symbol.TickSize;
            }
            else
            {
                slippagePoints = (fillPrice - requestedPrice) / symbol.TickSize;
            }

            LogExecution(symbol.Name, action, requestedPrice, fillPrice, slippagePoints, historyItem.VolumeInUnits, position.Id);
        }

        private void LogExecution(string symbol, string action, double requestedPrice, double fillPrice, double slippagePoints, double volume, int positionId)
        {
            // Enforce GMT alignment for 1:1 comparison against London cash hours
            DateTime timeGmt = Server.TimeInUtc;
            string timeStr = timeGmt.ToString("yyyy.MM.dd HH:mm:ss");
            long localMs = DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond;

            string logLine = $"{timeStr},{localMs},{symbol},{action},{requestedPrice},{fillPrice},{Math.Round(slippagePoints, 1)},{volume},{positionId}";

            // cTrader event handlers execute asynchronously; lock required to prevent I/O race conditions during rapid partial fills
            lock (_fileLock)
            {
                using (StreamWriter sw = File.AppendText(_filePath))
                {
                    sw.WriteLine(logLine);
                }
            }
            
            Print($"LOGGED -> {symbol} | {action} | Slippage: {Math.Round(slippagePoints, 1)} pts");
        }
    }
}