ExeWatch génère maintenant la stack trace complète pour Delphi Win32 et Win64 et dispose d'un nouveau plugin pour RAD Studio

Tu as un projet Delphi ou C++Builder qui tourne chez tes clients et tu voudrais savoir ce qui s'y passe, mais chaque fois que tu ouvres la page du SDK, tu penses à tout ce qu'il y a à configurer. Avec ExeWatch 1.90, j'ai essayé de tout faire depuis un menu de l'IDE. Je te raconte ce que contient le nouveau setup et ce que j'ai vraiment essayé.

TL;DR : ExeWatch 1.90 a un setup qui s’appelle ExeWatch for RAD Studio et ajoute un menu à l’IDE. Depuis ce menu, tu actives la télémétrie dans un projet Delphi ou C++Builder et tu reçois de tes clients erreurs, logs, métriques et timings. Les erreurs arrivent avec la stack trace (en Delphi avec unit, fonction et ligne, sur Win32 et Win64) grâce à la table des symboles placée dans l’exécutable. Ça marche à partir de XE8. Plus bas, tu trouves les étapes et les fenêtres. À la fin, tu trouves ce que j’ai vraiment essayé et ce que je n’ai pas essayé.

Ce qu’il y a de nouveau dans la 1.90

Pour la première fois, ExeWatch vit dans l’IDE. La 1.90.0 (SDK Delphi 0.25.0) a un setup unique et un menu dans RAD Studio : tu choisis une entrée et le projet que tu as ouvert a la télémétrie active, avec la table des symboles dans l’exécutable pour les stack traces. Pour moi, c’est la version qui met ExeWatch là où tu travailles déjà, sur ton projet. Je la montre en direct à ITDevCon 2026, à Rome les 19 et 20 novembre, puis aussi à EKON : les détails sont à la fin.

Télécharge le setup et essaie-le sur un de tes projets. Plus bas, tu trouves les étapes, une par une, avec les fenêtres que tu verras dans l’IDE : installation, menu, activation de la télémétrie et, pour finir, une stack trace.

Avant de commencer, regarde tout le parcours en un peu plus d’une minute : nouveau projet, ExeWatch activé depuis le menu, clé API, compilation et la stack trace qui arrive dans la console. La vidéo est en 1920×1080 : pour lire les détails, utilise le bouton plein écran du lecteur.

1. Installe le setup

Le setup s’appelle ExeWatch for RAD Studio et pèse environ 2,9 Mo. Il s’installe par utilisateur et ne demande pas de droits d’administrateur. Ce qu’il fait :

• il intègre l’expert dans l’IDE de chaque RAD Studio installé sur la machine, à partir de XE8 ;
• il copie les sources du SDK ;
• il installe l’outil en ligne de commande ExeWatchMapCLI.exe, celui que tu utilises dans les scripts de build et dans la CI ;
• il définit la variable d’environnement EXEWATCH_SDK, celle que tu retrouves ensuite dans le Library Path.

Tu le télécharges depuis ExeWatchRADStudioSetup.exe, sur le site d’ExeWatch : le lien est aussi la première étape de la liste “Setup” dans la section Delphi de la page d’accueil. Si tu as un Delphi ou un C++Builder plus ancien que XE8, ou si tu utilises un autre langage, la page d’accueil propose l’onglet “DLL”.

2. Ouvre le menu ExeWatch

Ouvre un projet, va dans Project > ExeWatch. Le même menu se trouve aussi dans le menu contextuel du projet dans le Project Manager. Il contient trois entrées.

3. Enable ExeWatch Telemetry

C’est l’entrée qui t’évite le travail à la main. Tu la choisis, et l’expert :

1. crée dans le projet ExeWatchConfig.pas ;
2. ajoute au projet les unit du SDK (ExeWatchSDKv1, plus l’unit pour VCL ou FMX) ;
3. insère StartExeWatch et FlushExeWatch dans le fichier principal : le .dpr en Delphi, le .cpp en C++Builder.

À la fin, une fenêtre t’explique ce qui a été fait. Si tu veux voir ce qui a changé dans les fichiers du projet, tu as le diff de ton système de gestion de versions.

La même fenêtre active aussi Link map file pour ce projet : on y vient dans un instant.

Voici le .dpr d’une application VCL de test (PlainVcl) après le clic, dans Delphi 13 :

program PlainVcl;

uses
  Vcl.Forms,
  MainU in 'MainU.pas' {MainForm},
  ExeWatchConfig in 'ExeWatchConfig.pas',
  ExeWatchSDKv1,
  ExeWatchSDKv1.VCL;

{$R *.res}

begin
  StartExeWatch;
  Application.Initialize;
  Application.MainFormOnTaskbar := True;
  Application.CreateForm(TMainForm, MainForm);
  Application.Run;
  FlushExeWatch;
end.

Et voici la ligne que l’IDE écrit dans la fenêtre Messages au build suivant :

[ExeWatch] PlainVcl.dproj(1): PlainVcl.exe: map linked (51812 symbols)

La clé API

Dans l’unit générée, tu ne changes qu’une seule constante : EXEWATCH_API_KEY.

const
  EXEWATCH_API_KEY = 'api-key-from-the-ExeWatch-console';
  EXEWATCH_PLACEHOLDER_CUSTOMER = 'customer-id';

Tu prends la clé dans la console d’ExeWatch. La page API Keys de l’app t’affiche déjà le code prêt avec la clé dedans et un bouton “Copy the key” : tu copies et tu colles. Une clé Windows commence par ew_win_.

Le customer

Le customer n’est pas une constante à modifier. Il dit à ExeWatch pour quel client tourne l’application, donc tu le lis dans la licence (ou dans le login, ou dans un réglage). Tu as deux façons de le donner à ExeWatch.

Si tu le connais déjà au démarrage, tu le passes directement à StartExeWatch :

StartExeWatch('ACME-Corp'); // the value read from the customer's license

Si tu le connais plus tard, par exemple après le login, tu démarres ExeWatch sans paramètre et tu le passes quand tu l’as, avec SetExeWatchCustomer :

StartExeWatch;
// ... later, when the customer is known:
SetExeWatchCustomer('ACME-Corp');

Le paramètre fictif généré est customer-id, et je l’ai laissé ainsi exprès : une intégration “de base” logue quand même, et tu vois tout de suite ce que tu dois changer.

4. Link map file

C’est une option par projet. Quand elle est activée, à la fin du build la table des symboles est écrite dans l’exécutable, dans une section PE appelée .ewmap. Ton client n’a aucun .map à distribuer à côté de l’exe.

L’alternative reste disponible : si tu préfères garder le .map à côté de l’exécutable, ça fonctionne toujours.

Un point pour ceux qui signent leurs exécutables avec Authenticode : la table doit être écrite avant la signature, parce que la section ajoutée invalide une signature déjà posée.

5. Provoque une erreur et regarde la stack trace

Pour l’essayer, j’ai utilisé PlainVcl, l’application VCL de tout à l’heure, avec un bouton qui enregistre une commande et un contrôle qui échoue :

procedure TMainForm.CheckTotals(Total, Invoiced: Currency);
begin
  if Total <> Invoiced then
    raise Exception.Create('The order total does not match the invoice');
end;

procedure TMainForm.SaveOrder;
begin
  CheckTotals(100, 90);
end;

procedure TMainForm.SaveButtonClick(Sender: TObject);
begin
  SaveOrder;
end;

Dans le gestionnaire, il n’y a aucun appel à ExeWatch : l’exception non gérée d’un OnClick, il la capture tout seul. StartExeWatch et FlushExeWatch dans le .dpr, ajoutés par le menu, suffisent. Le customer ACME-Corp, je l’ai passé avec SetExeWatchCustomer dans le FormCreate du form.

Tu compiles, tu appuies sur le bouton et tu ouvres la console d’ExeWatch. Dans le détail du log, tu trouves l’exception, le customer et la stack trace :

Voici les premières lignes de la stack trace, en Win32 :

MainFormU.TMainForm.CheckTotals (line 37)
MainFormU.TMainForm.SaveOrder (line 41)
MainFormU.TMainForm.SaveButtonClick (line 46)
Vcl.Controls.TControl.Click
Vcl.Controls.TWinControl.WndProc
Vcl.StdCtrls.TButtonControl.WndProc
Vcl.Controls.DoControlMsg
Vcl.Controls.TWinControl.WndProc
Vcl.Forms.TCustomForm.WndProc
Vcl.Controls.TWinControl.MainWndProc
System.Classes.StdWndProc

En haut, il y a ton code, avec unit, fonction et ligne. Ensuite vient la VCL, qui amène le clic jusqu’au gestionnaire. Après, il y a les frames système, qui sont des noms de fonctions exportées par Windows, et d’autres WndProc : en tout 31 frames, je montre les premières. Compilé en 64 bits, le même projet donne le même chemin : CheckTotals, SaveOrder, SaveButtonClick, puis Vcl.Controls.TControl.Click.

La console de la capture est une instance de test d’ExeWatch 1.90, avec des données de test.

Les stack traces, sur Win32 et sur Win64

La stack trace est l’un des outils qu’ExeWatch te donne, à côté des logs, des métriques et des timings. Quand une exception arrive d’un client, c’est l’un des plus utiles, parce qu’elle te dit où elle a été levée. Ce que tu obtiens dépend du langage.

Delphi, Win32 et Win64, Debug et Release. Chaque exception arrive avec unit, fonction et numéro de ligne, et la trace part de l’endroit où l’exception a été levée. Ça marche aussi en 32 bits.

C++Builder. Le menu est le même : Enable ExeWatch Telemetry ajoute au projet ExeWatchConfig.pas et les unit du SDK, et insère StartExeWatch(); et FlushExeWatch(); dans le .cpp principal. Le projet compile lui-même les unit du SDK, donc pas de DLL à distribuer et pas d’import library à lier. La stack trace a les noms de fonction mais pas les numéros de ligne, parce que le map du linker C++ ne les contient pas. Une exception lancée avec throw depuis le C++ arrive avec message, classe, breadcrumbs, utilisateur et tags, mais pour l’instant sans stack trace, et sur Win64x les noms ne sont pas résolus. Cette partie, je l’ai vérifiée avec RAD Studio 12 et 13.

La DLL du SDK. Elle capture les exceptions levées dans son propre code et dans un hôte qui utilise le même runtime Delphi. Un hôte avec un autre runtime, comme MSVC ou Python, n’obtient pas la stack trace de ses propres exceptions.

Pas seulement la stack trace : la santé de tes projets chez le client

La stack trace te dit où une erreur a explosé. Pour savoir comment vont tes applications chez tes clients, il faut autre chose, et ExeWatch le collecte au même endroit :

• les erreurs, avec la stack trace, regroupées par problème, version, customer et device, pour voir qui est touché et depuis quand ;
• les logs et les métriques des applications ;
• les timings, y compris imbriqués, pour comprendre où part le temps ;
• l’usage réel des applications et les versions installées chez chaque client ;
• un agent IA qui lit les erreurs via MCP et en ligne de commande, comme je le raconte dans ExeWatchMCP, KAI et la production de tes clients.

Pour moi, c’est la solution la plus complète pour garder sous contrôle la santé de tes projets chez le client. Si tu utilises déjà en production un outil qui capture les exceptions et produit la stack trace, ExeWatch ne le remplace pas : il t’apporte aussi tout le reste, et il cohabite avec ce que tu as (j’en ai parlé dans ExeWatch et madExcept ensemble). Tu peux commencer avec un compte gratuit.

En ligne de commande : ExeWatchMapCLI

En dehors de l’IDE (script de build, CI, agent IA), la table des symboles se lie avec ExeWatchMapCLI.exe, juste après le build, sur l’exécutable. Le setup l’a déjà installé dans le dossier bin et tu peux le mettre dans le PATH :

ExeWatchMapCLI.exe MyApp.exe
ExeWatchMapCLI.exe MyApp.exe C:\build\MyApp.map --delete-map

La table se retrouve dans l’exécutable, comme avec le menu de l’IDE. Dans l’onglet Command line du Playground, il y a aussi un texte d’instructions prêt à donner à un agent IA, avec les réglages de build, la commande, comment lire le résultat et quoi faire à chaque erreur.

Le Playground

La troisième entrée du menu, Playground and updates…, ouvre une fenêtre à quatre onglets.

Try your key. Tu colles la clé de l’application et tu appuies sur “Check the key”, qui envoie une ligne de debug, ou sur “Send sample logs”, qui en envoie quatre (debug, info, warning, error). Tu vois la réponse du serveur dans la fenêtre. Toutes ces lignes portent le tag exewatch-ide-test et comptent dans le volume mensuel du compte.

Guide and AI. Les liens vers le guide et les commandes pour faire lire les erreurs à un agent IA via le serveur MCP. Si tu ne vois pas de quoi je parle, j’en ai parlé dans ExeWatchMCP, KAI et la production de tes clients.

Command line. Celle dont je parlais plus haut.

SDK and updates. La version installée, la dernière disponible, l’urgence de la mise à jour et ce qui a changé.

De XE8 à 13

La déclaration de support est XE8 et suivantes. Voici ce que j’ai vraiment essayé et ce que je n’ai pas essayé :

• l’intégration dans l’IDE, je l’ai essayée en direct dans XE8 et dans Delphi 13 ;
• le niveau IDE compile sur XE8, 12 et 13 ;
• le SDK natif compile de XE8 à 13, Win32 et Win64, et en cross-compilation Linux64 avec Delphi 13 ;
• depuis cette version, la suite de tests du SDK tourne aussi sur XE8, en plus de 12 et 13.

Les versions intermédiaires, je ne les ai pas essayées une par une, et je préfère te le dire.

En direct : je t’attends à ITDevCon 2026

ITDevCon 2026, Rome, 19 et 20 novembre. C’est là que je te montre ExeWatch for RAD Studio en direct, avec l’intégration dans l’IDE : le setup, le menu, la stack trace qui arrive dans la console. Apporte un de tes projets et les questions que tu veux. Billets ici, le site est itdevcon.it.

Les interventions où il est question d’ExeWatch, toutes les deux en salle Kirk :

• KAI + ExeWatch: il mondo Delphi non sarà più lo stesso (KAI + ExeWatch : le monde Delphi ne sera plus jamais le même), de 10 h 35 à 11 h 30 ;
• ExeWatch: 500 persone stanno usando il tuo software in questo momento. Un crash report non ti dirà come sta andando. (ExeWatch : 500 personnes utilisent ton logiciel en ce moment. Un crash report ne te dira pas comment ça se passe.), de 15 h 05 à 16 h 00.

Le programme de toutes mes interventions se trouve sur ma page parmi les intervenants d’ITDevCon.

Je le présente aussi à EKON 30, l’édition des trente ans, Meliá Düsseldorf, du 23 au 27 novembre 2026. Billets ici, et ma page parmi les intervenants.

Essaie sur un de tes projets

Télécharge le setup, ouvre un projet que tu as déjà, et choisis Project > ExeWatch > Enable ExeWatch Telemetry. Ensuite, logue sans te ménager : plus ExeWatch voit de choses, plus il t’est utile quand un client téléphone. Si tu veux voir ce qu’on peut faire avec les données qui arrivent, j’ai écrit sur les mises à jour et l’usage réel de tes applications et sur les timings imbriqués. Tout le reste est sur exewatch.com.

Questions fréquentes

Qu’est-ce qu’ExeWatch for RAD Studio ? C’est le setup d’ExeWatch 1.90 qui ajoute un menu à l’IDE de Delphi et C++Builder pour activer la télémétrie dans un projet et lier la table des symboles à l’exécutable.

À partir de quelle version de RAD Studio ça marche ? À partir de XE8. L’intégration a été essayée en direct dans l’IDE de XE8 et de Delphi 13 ; le niveau IDE compile sur XE8, 12 et 13.

Faut-il des droits d’administrateur ? Non. Le setup s’installe par utilisateur.

La stack trace fonctionne-t-elle sur Win32 et sur Win64 ? Oui, en Delphi : unit, fonction et numéro de ligne, Debug et Release. Ce qu’elle donne en C++Builder est expliqué dans un paragraphe à part dans l’article.

Dois-je distribuer un fichier .map avec l’exécutable ? Non, si la table est liée dans l’exécutable (option “Link map file”, section PE .ewmap). Le .map à côté de l’exe reste possible comme alternative.

Où mettre le customer ? Ce n’est pas une constante : tu le lis dans la licence du client et tu le passes directement à StartExeWatch('ACME-Corp'), ou plus tard avec SetExeWatchCustomer. Le paramètre fictif généré est customer-id.

Où le voir en direct ? Surtout à ITDevCon 2026 (Rome, 19 et 20 novembre) : Daniele Teti le montre en direct là-bas. Il le présente aussi à EKON 30 (Düsseldorf, du 23 au 27 novembre).