ExeWatch ora genera lo stack trace completo per Delphi Win32 e Win64 e ha un nuovo plugin per RAD Studio

Hai un progetto Delphi o C++Builder che gira dai clienti e vorresti sapere cosa gli succede, ma ogni volta che apri la pagina dell'SDK ti viene in mente tutto quello che c'è da configurare. Con ExeWatch 1.90 ho provato a fare tutto da un menu dell'IDE. Ti racconto cosa c'è dentro il nuovo setup e cosa ho provato davvero.

TL;DR: ExeWatch 1.90 ha un setup che si chiama ExeWatch for RAD Studio e aggiunge un menu all’IDE. Da lì attivi la telemetria in un progetto Delphi o C++Builder e ricevi dai tuoi clienti errori, log, metriche e timing. Gli errori arrivano con lo stack trace (in Delphi con unit, funzione e riga, su Win32 e Win64) grazie alla mappa dei simboli dentro l’eseguibile. Funziona da XE8 in poi. Sotto trovi i passaggi e le finestre. In fondo trovi cosa ho provato davvero e cosa no.

Cosa c’è di nuovo nella 1.90

Per la prima volta ExeWatch vive dentro l’IDE. La 1.90.0 (SDK Delphi 0.25.0) ha un setup unico e un menu in RAD Studio: scegli una voce e il progetto che hai aperto ha la telemetria attiva, con la mappa dei simboli dentro l’eseguibile per gli stack trace. Per me è la release che mette ExeWatch dove stai già lavorando, sul tuo progetto. La mostro dal vivo a ITDevCon 2026, a Roma il 19 e 20 novembre, e poi anche a EKON: i dettagli in fondo.

Scarica il setup e provalo su un progetto tuo. Qui sotto trovi i passi, uno alla volta, con le finestre che vedrai nell’IDE: installazione, menu, attivazione della telemetria e, alla fine, uno stack trace.

Prima di cominciare, guarda tutto il percorso in poco più di un minuto: nuovo progetto, attivazione di ExeWatch dal menu, chiave API, build e lo stack trace che arriva nella console. Il video è a 1920×1080: per leggere i dettagli usa il pulsante a schermo intero del player.

1. Installa il setup

Il setup si chiama ExeWatch for RAD Studio, pesa circa 2,9 MB. Installa per utente e non chiede diritti di amministratore. Cosa fa:

• integra l’expert nell’IDE di ogni RAD Studio installato sulla macchina, da XE8 in poi;
• copia i sorgenti dell’SDK;
• installa lo strumento a riga di comando ExeWatchMapCLI.exe, quello che usi negli script di build e nella CI;
• imposta la variabile d’ambiente EXEWATCH_SDK, che è quella che trovi poi nel Library Path.

Si scarica da ExeWatchRADStudioSetup.exe, dal sito di ExeWatch: il link è anche il primo passo dell’elenco “Setup” nella sezione Delphi della home. Se hai un Delphi o un C++Builder più vecchi di XE8, o usi un altro linguaggio, nella home c’è la scheda “DLL”.

2. Apri il menu ExeWatch

Apri un progetto, vai in Project > ExeWatch. Lo stesso menu c’è anche nel menu contestuale del progetto in Project Manager. Contiene tre voci.

3. Enable ExeWatch Telemetry

È la voce che ti evita il lavoro a mano. La scegli, e l’expert:

1. crea nel progetto ExeWatchConfig.pas;
2. aggiunge al progetto le unit dell’SDK (ExeWatchSDKv1, più la unit per VCL o FMX);
3. inserisce StartExeWatch e FlushExeWatch nel file principale: il .dpr in Delphi, il .cpp in C++Builder.

Alla fine una finestra ti spiega cosa è stato fatto. Se vuoi vedere cosa è cambiato nei file del progetto, hai il diff del tuo sistema di versionamento.

La stessa finestra accende anche Link map file per quel progetto: ci arriviamo fra poco.

Questo è il .dpr di un’applicazione VCL di prova (PlainVcl) dopo il clic, in 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.

E questa è la riga che l’IDE scrive nella finestra Messages alla build successiva:

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

La chiave API

Nell’unit generata cambi una costante sola: EXEWATCH_API_KEY.

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

La chiave la prendi dalla console di ExeWatch. La pagina API Keys dell’app ti mostra già il codice pronto con la chiave dentro e un bottone “Copy the key”: copi e incolli. Una chiave Windows inizia con ew_win_.

Il customer

Il customer non è una costante da modificare. Ti dice per quale cliente sta girando l’applicazione, quindi lo leggi dalla licenza (o dal login, o da un’impostazione). Hai due modi per darlo a ExeWatch.

Se lo conosci già all’avvio, lo passi direttamente a StartExeWatch:

StartExeWatch('ACME-Corp'); // il valore letto dalla licenza del cliente

Se lo conosci più tardi, per esempio dopo il login, avvii ExeWatch senza parametri e lo passi quando lo hai, con SetExeWatchCustomer:

StartExeWatch;
// ... più avanti, quando il cliente è noto:
SetExeWatchCustomer('ACME-Corp');

Il segnaposto generato è customer-id, e l’ho lasciato così apposta: un’integrazione “base” logga comunque, e ti accorgi subito di cosa devi cambiare.

4. Link map file

È un’opzione per progetto. Quando è accesa, a fine build la mappa dei simboli viene scritta dentro l’eseguibile, in una sezione PE chiamata .ewmap. Il cliente non deve distribuire nessun .map accanto all’exe.

L’alternativa resta: se preferisci tenere il .map accanto all’eseguibile, funziona ancora.

Una cosa per chi firma gli eseguibili con Authenticode: la mappa va scritta prima della firma, perché la sezione aggiunta invalida una firma già apposta.

5. Provoca un errore e guarda lo stack trace

Per provarlo ho usato PlainVcl, l’applicazione VCL di prima, con un pulsante che salva un ordine e un controllo che fallisce:

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;

Nel gestore non c’è nessuna chiamata a ExeWatch: l’eccezione non gestita di un OnClick la cattura da solo. Bastano StartExeWatch e FlushExeWatch nel .dpr, che ha messo il menu. Il customer ACME-Corp l’ho passato con SetExeWatchCustomer nel FormCreate del form.

Compili, premi il pulsante e apri la console di ExeWatch. Nel dettaglio del log trovi l’eccezione, il customer e lo stack trace:

Queste sono le prime righe dello stack trace, in 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

In cima c’è il tuo codice, con unit, funzione e riga. Poi viene la VCL, che porta il clic fino al gestore. Dopo ci sono i frame di sistema, che sono nomi di funzioni esportate da Windows, e altre WndProc: in tutto 31 frame, io ne mostro i primi. Compilato a 64 bit, lo stesso progetto dà lo stesso percorso: CheckTotals, SaveOrder, SaveButtonClick, poi Vcl.Controls.TControl.Click.

La console dello screenshot è un’istanza di prova di ExeWatch 1.90, con dati di prova.

Gli stack trace, su Win32 e su Win64

Lo stack trace è uno degli strumenti che ExeWatch ti dà, accanto a log, metriche e timing. Quando un’eccezione arriva da un cliente è uno dei più utili, perché ti dice dove è stata sollevata. Cosa ottieni dipende dal linguaggio.

Delphi, Win32 e Win64, Debug e Release. Ogni eccezione arriva con unit, funzione e numero di riga, e la traccia parte dal punto in cui l’eccezione è stata sollevata. Funziona anche sui 32 bit.

C++Builder. Il menu è lo stesso: Enable ExeWatch Telemetry aggiunge al progetto ExeWatchConfig.pas e le unit dell’SDK e inserisce StartExeWatch(); e FlushExeWatch(); nel .cpp principale. Il progetto compila da solo le unit dell’SDK, quindi niente DLL da distribuire e niente import library da linkare. Lo stack trace ha i nomi di funzione ma non i numeri di riga, perché il map del linker C++ non li contiene. Un’eccezione lanciata con throw dal C++ arriva con messaggio, classe, breadcrumb, utente e tag, ma per ora senza stack trace, e su Win64x i nomi non vengono risolti. Questa parte l’ho verificata con RAD Studio 12 e 13.

La DLL dell’SDK. Cattura le eccezioni sollevate nel suo codice e in un host che usa lo stesso runtime Delphi. Un host con un altro runtime, come MSVC o Python, non ottiene lo stack trace delle proprie eccezioni.

Non solo stack trace: la salute dei tuoi progetti dal cliente

Lo stack trace ti dice dove è esploso un errore. Per sapere come stanno le tue applicazioni presso i clienti serve altro, e ExeWatch lo raccoglie nello stesso posto:

• gli errori, con lo stack trace, raggruppati per problema, versione, customer e device, così vedi chi è colpito e da quando;
• i log e le metriche delle applicazioni;
• i timing, anche annidati, per capire dove va il tempo;
• l’uso reale delle applicazioni e le versioni installate da ogni cliente;
• un agente AI che legge gli errori via MCP e da riga di comando, come racconto in ExeWatchMCP, KAI e la produzione dei tuoi clienti.

Per me è la soluzione più completa per tenere sotto controllo la salute dei tuoi progetti presso il cliente. Se in produzione usi già uno strumento che cattura le eccezioni e produce lo stack trace, ExeWatch non lo sostituisce: ti dà anche tutto il resto, e convive con quello che hai (ne ho scritto in ExeWatch e madExcept insieme). Puoi cominciare con un account gratuito.

Da riga di comando: ExeWatchMapCLI

Fuori dall’IDE (script di build, CI, un agente AI) la mappa si collega con ExeWatchMapCLI.exe, subito dopo la build, sull’eseguibile. Il setup l’ha già installato nella cartella bin e lo puoi mettere nel PATH:

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

La mappa finisce nell’eseguibile, come con il menu dell’IDE. Nella scheda Command line del Playground c’è anche un testo di istruzioni pronto da dare a un agente AI, con le impostazioni di build, il comando, come leggere il risultato e cosa fare a ogni errore.

Il Playground

La terza voce del menu, Playground and updates…, apre una finestra con quattro schede.

Try your key. Incolli la chiave dell’applicazione e premi “Check the key”, che invia una riga di debug, oppure “Send sample logs”, che ne invia quattro (debug, info, warning, error). Vedi la risposta del server nella finestra. Tutte portano il tag exewatch-ide-test e contano nel volume mensile dell’account.

Guide and AI. I collegamenti alla guida e i comandi per far leggere gli errori a un agente AI tramite il server MCP. Se non sai di cosa parlo, ne ho scritto in ExeWatchMCP, KAI e la produzione dei tuoi clienti.

Command line. Quella di cui sopra.

SDK and updates. La versione installata, l’ultima disponibile, l’urgenza dell’aggiornamento e cosa è cambiato.

Da XE8 a 13

La dichiarazione di supporto è XE8 e successivi. Ecco cosa ho provato davvero e cosa no:

• l’integrazione nell’IDE l’ho provata dal vivo in XE8 e in Delphi 13;
• il livello IDE compila su XE8, 12 e 13;
• l’SDK nativo compila da XE8 a 13, Win32 e Win64, e in cross-compile Linux64 con Delphi 13;
• da questa release la suite di test dell’SDK gira anche su XE8, oltre che su 12 e 13.

Le versioni in mezzo non le ho provate una per una, e preferisco dirtelo.

Dal vivo: ti aspetto a ITDevCon 2026

ITDevCon 2026, Roma, 19 e 20 novembre. È il posto dove ti faccio vedere ExeWatch for RAD Studio dal vivo, con l’integrazione nell’IDE: il setup, il menu, lo stack trace che arriva in console. Porta un progetto tuo e le domande che vuoi. Biglietti qui, il sito è itdevcon.it.

Gli interventi in cui c’è ExeWatch, entrambi nella Sala Kirk:

• KAI + ExeWatch: il mondo Delphi non sarà più lo stesso, dalle 10:35 alle 11:30;
• ExeWatch: 500 persone stanno usando il tuo software in questo momento. Un crash report non ti dirà come sta andando., dalle 15:05 alle 16:00.

Il programma con tutti i miei interventi è nella mia pagina fra i relatori di ITDevCon.

Lo porto anche a EKON 30, l’edizione del trentennale, Meliá Düsseldorf, dal 23 al 27 novembre 2026. Biglietti qui, e la mia pagina fra i relatori.

Provalo su un progetto tuo

Scarica il setup, apri un progetto che hai già, e scegli Project > ExeWatch > Enable ExeWatch Telemetry. Poi logga senza risparmiarti: più ExeWatch vede, più ti è utile quando un cliente telefona. Se vuoi vedere cosa si può fare con i dati che arrivano, ho scritto degli aggiornamenti e dell’uso reale delle tue applicazioni e dei timing annidati. Tutto il resto è su exewatch.com.

Domande frequenti

Cos’è ExeWatch for RAD Studio? È il setup di ExeWatch 1.90 che aggiunge un menu all’IDE di Delphi e C++Builder per attivare la telemetria in un progetto e collegare la mappa dei simboli all’eseguibile.

Da quale versione di RAD Studio funziona? Da XE8 in poi. L’integrazione è stata provata dal vivo nell’IDE di XE8 e di Delphi 13; il livello IDE compila su XE8, 12 e 13.

Servono i diritti di amministratore? No. Il setup installa per utente.

Lo stack trace funziona su Win32 e su Win64? Sì, in Delphi: unit, funzione e numero di riga, Debug e Release. Cosa fa in C++Builder è spiegato in un paragrafo a parte nell’articolo.

Devo distribuire un file .map insieme all’eseguibile? No, se la mappa è collegata nell’eseguibile (opzione “Link map file”, sezione PE .ewmap). Il .map accanto all’exe resta come alternativa.

Dove metto il customer? Non è una costante: lo leggi dalla licenza del cliente e lo passi direttamente a StartExeWatch('ACME-Corp'), oppure più tardi con SetExeWatchCustomer. Il segnaposto generato è customer-id.

Dove lo vedo dal vivo? Soprattutto a ITDevCon 2026 (Roma, 19 e 20 novembre): Daniele Teti lo mostra dal vivo lì. Lo porta anche a EKON 30 (Düsseldorf, dal 23 al 27 novembre).