Trading algorithmique · Infrastructure
Surveiller ses robots de trading en production : alertes, contrôles et détection de dérive
Un robot ne se surveille pas en regardant son solde. Pannes techniques, positions sans stop, dérive par rapport au backtest : le dispositif de surveillance qui détecte les problèmes avant qu’ils ne coûtent cher.
Surveiller un robot de trading en production, c’est vérifier en continu trois choses distinctes : que l’infrastructure fonctionne (serveur allumé, terminal connecté, trading autorisé), que le robot fait ce qu’il est censé faire (positions protégées, pas d’ordres en boucle, volume conforme) et que ses résultats restent compatibles avec ce que le backtest laissait prévoir. Les deux premiers contrôles se font en temps réel par des alertes automatiques ; le troisième se fait périodiquement, à partir de statistiques. Regarder son solde une fois par jour ne couvre aucun des trois.
Cette page conclut la rubrique Infrastructure du trading automatique. Elle propose un dispositif proportionné, utilisable avec un seul robot comme avec un portefeuille, et un exemple de code MQL5 de surveillance.
Les trois niveaux de surveillance
Niveau 1 : l’infrastructure
Questions à poser en permanence : le serveur tourne-t-il ? Le terminal est-il connecté au serveur de trading ? Le trading automatique est-il autorisé ? Le robot est-il toujours attaché au graphique ? Une réponse négative à l’une d’elles signifie que vos positions ne sont plus gérées. Ce niveau demande des alertes immédiates.
Niveau 2 : le comportement du robot
Ici, l’infrastructure fonctionne, mais le robot peut mal se comporter : une position ouverte sans stop loss, un volume supérieur à la limite prévue, un nombre de trades anormal dans la journée, des refus d’ordres répétés, une perte journalière qui dépasse le seuil fixé. Ce sont les symptômes d’un bug, d’un changement de conditions chez le courtier ou d’un marché exceptionnel. Ils demandent aussi une alerte rapide.
Niveau 3 : la performance
Le robot fonctionne et se comporte normalement, mais ses résultats s’écartent-ils de ce que le test laissait attendre ? Ce contrôle est statistique : on ne juge pas un robot sur trois trades. Il se fait chaque semaine ou chaque mois, en comparant les indicateurs réels à leur distribution attendue.
Le problème du robot qui ne peut pas signaler sa propre panne
Un robot peut envoyer une notification quand il détecte un problème. Il ne peut pas en envoyer quand le serveur est éteint ou le terminal figé. La solution est le battement de cœur : le robot émet un signal régulier, et c’est l’absence de signal qui déclenche l’alerte. Concrètement, deux approches :
- le robot envoie une notification de statut à heure fixe (par exemple chaque matin) : si vous ne la recevez pas, quelque chose ne va pas ;
- le robot écrit périodiquement un horodatage dans un fichier ou l’envoie à un service externe, et un second système, hébergé ailleurs, vous alerte si l’horodatage n’est pas mis à jour.
La seconde approche est plus fiable car elle ne dépend pas de votre attention, mais elle demande un outil externe. La première est un minimum accessible à tous.
Exemple : un Expert Advisor de surveillance en MQL5
Le programme ci-dessous tourne sur un graphique à part, sans trader. Toutes les minutes, il vérifie la connexion, l’autorisation de trading, la présence d’un stop loss sur chaque position et le drawdown des capitaux propres depuis leur plus haut. Il envoie une notification push en cas d’anomalie, avec une temporisation pour respecter les limites de SendNotification() (selon la documentation, au plus 2 appels par seconde et 10 par minute, 255 caractères par message), et un message de statut quotidien qui sert de battement de cœur.
//+------------------------------------------------------------------+
//| Watchdog.mq5 : surveillance d'un compte de trading automatique |
//+------------------------------------------------------------------+
#property version "1.00"
input double InpMaxDDPct = 10.0; // alerte si drawdown des capitaux propres > X %
input int InpStatusHour = 8; // heure (serveur) du message de statut quotidien
input int InpAlertPause = 900; // délai minimal entre deux alertes identiques (s)
double g_peakEquity = 0.0; // plus haut des capitaux propres observé
datetime g_lastAlert[4]; // horodatage de la dernière alerte par type
int g_lastStatusDay = -1; // jour du dernier message de statut
//--- envoie une notification si le type d'alerte n'a pas été envoyé récemment
void Notify(const int type, const string text)
{
if(TimeCurrent() - g_lastAlert[type] < InpAlertPause)
return;
g_lastAlert[type] = TimeCurrent();
Print(text); // trace dans le journal
if(!TerminalInfoInteger(TERMINAL_NOTIFICATIONS_ENABLED))
return;
ResetLastError();
if(!SendNotification(StringSubstr(text, 0, 255)))
Print("Échec SendNotification, erreur ", GetLastError());
}
int OnInit()
{
ArrayInitialize(g_lastAlert, 0);
g_peakEquity = AccountInfoDouble(ACCOUNT_EQUITY);
return(EventSetTimer(60) ? INIT_SUCCEEDED : INIT_FAILED);
}
void OnDeinit(const int reason) { EventKillTimer(); }
void OnTimer()
{
//--- 1. infrastructure
if(!TerminalInfoInteger(TERMINAL_CONNECTED))
Notify(0, "Terminal déconnecté du serveur de trading");
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
Notify(1, "Trading automatique désactivé dans le terminal");
//--- 2. positions sans stop loss
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i); // sélectionne la position
if(ticket > 0 && PositionGetDouble(POSITION_SL) == 0.0)
Notify(2, "Position sans SL : " + PositionGetString(POSITION_SYMBOL) +
" ticket " + (string)ticket);
}
//--- 3. drawdown des capitaux propres depuis le plus haut
double equity = AccountInfoDouble(ACCOUNT_EQUITY);
if(equity > g_peakEquity)
g_peakEquity = equity;
double dd = (g_peakEquity > 0.0) ? 100.0 * (g_peakEquity - equity) / g_peakEquity : 0.0;
if(dd > InpMaxDDPct)
Notify(3, StringFormat("Drawdown %.1f %% (equity %.2f)", dd, equity));
//--- 4. battement de cœur quotidien
MqlDateTime t;
TimeToStruct(TimeCurrent(), t);
if(t.hour == InpStatusHour && t.day_of_year != g_lastStatusDay)
{
g_lastStatusDay = t.day_of_year;
SendNotification(StringFormat("Statut OK - equity %.2f - positions %d - DD %.1f %%",
equity, PositionsTotal(), dd));
}
}
void OnTick() {}
Ce code reste volontairement simple. Le plus haut des capitaux propres est perdu au redémarrage : pour un usage durable, enregistrez-le dans une variable globale du terminal ou un fichier. Les notifications push exigent que l’identifiant MetaQuotes de votre téléphone soit renseigné dans les options du terminal. Les fonctions disponibles sont présentées dans la page Alertes, e-mails et notifications push.
Le tableau de bord hebdomadaire
Pour le niveau 3, tenez un tableau simple, robot par robot, mis à jour chaque semaine :
| Indicateur | Réel | Attendu (backtest) | Commentaire |
|---|---|---|---|
| Nombre de trades | à relever | fréquence moyenne du test | Un écart fort signale un problème de signal ou de données |
| Taux de réussite | à relever | valeur du test | Juger sur un nombre suffisant de trades |
| Gain et perte moyens | à relever | valeurs du test | Un gain moyen plus faible évoque des coûts plus élevés |
| Slippage moyen | à relever | hypothèse du test | À comparer à l’hypothèse de coût |
| Drawdown en cours | à relever | drawdown maximal du test | Repère principal de décision |
Le drawdown en cours se lit à l’aune du drawdown maximal observé en test et, mieux, de la distribution obtenue par simulation. Le calculateur de drawdown vous aide à quantifier la perte et l’effort de remontée correspondant.
Définir à l’avance les règles d’arrêt
La surveillance n’a d’intérêt que si vous savez quoi faire de l’information. Écrivez avant le démarrage, pour chaque robot, les règles qui déclenchent une action :
- arrêt immédiat : position sans stop, volume anormal, ordres en boucle, comportement inexpliqué ;
- suspension et analyse : drawdown supérieur à un multiple fixé du drawdown maximal du test, série de pertes plus longue que toutes celles du test ;
- réduction de taille : performance durablement inférieure à l’attendu sans dépassement des seuils d’arrêt.
Décider ces seuils à froid évite les deux erreurs symétriques : couper un robot sain au creux d’un drawdown normal, ou laisser tourner un robot cassé par espoir d’un rebond.
Pièges fréquents
- Trop d’alertes. Un téléphone qui sonne toutes les dix minutes finit ignoré. Réservez les alertes immédiates aux niveaux 1 et 2.
- Surveiller depuis la même machine. Un contrôle hébergé sur le VPS surveillé ne peut pas signaler la panne du VPS.
- Juger la performance trop tôt. Quelques trades ne permettent aucune conclusion statistique.
- Ne pas journaliser. Sans trace des ordres, prix demandés et obtenus, aucune analyse a posteriori n’est possible.
- Oublier de tester les alertes. Provoquez volontairement chaque alerte sur un compte de démonstration (déconnexion, position sans stop) pour vérifier qu’elle arrive bien sur votre téléphone, puis refaites ce test après chaque changement de serveur ou de terminal.
Questions fréquentes
Comment être prévenu si mon VPS s’arrête ?
Un programme qui tourne sur le VPS ne peut pas signaler sa propre panne. Utilisez un battement de cœur : un message de statut envoyé à heure fixe dont l’absence vous alerte, ou un horodatage transmis à un service externe qui déclenche une alerte s’il n’est plus mis à jour.
À partir de quel drawdown faut-il arrêter un robot ?
Fixez le seuil avant le démarrage, en référence au drawdown maximal observé en test et à la distribution obtenue par simulation de Monte-Carlo. Un dépassement net de ces repères justifie une suspension et une analyse ; un drawdown dans les limites attendues n’en justifie généralement pas.
SendNotification fonctionne-t-elle dans le Strategy Tester ?
Non. Selon la documentation MQL5, la fonction ne fonctionne pas dans le testeur de stratégie. Testez votre dispositif d’alerte sur un compte de démonstration.
Faut-il surveiller chaque robot séparément ?
Oui pour le comportement et la performance, car chaque robot a ses propres références de test. Les contrôles d’infrastructure et le drawdown global peuvent en revanche être centralisés par compte.
