ExeWatch erzeugt jetzt den vollständigen Stack Trace für Delphi Win32 und Win64 und hat ein neues Plugin für RAD Studio

Du hast ein Delphi- oder C++Builder-Projekt, das bei deinen Kunden läuft, und würdest gern wissen, was dort damit passiert. Aber jedes Mal, wenn du die SDK-Seite öffnest, fällt dir ein, was alles zu konfigurieren ist. Mit ExeWatch 1.90 habe ich versucht, das alles über ein Menü der IDE zu erledigen. Ich erzähle dir, was im neuen Setup steckt und was ich wirklich ausprobiert habe.

TL;DR: ExeWatch 1.90 hat ein Setup namens ExeWatch for RAD Studio, das der IDE ein Menü hinzufügt. Darüber aktivierst du die Telemetrie in einem Delphi- oder C++Builder-Projekt und bekommst von deinen Kunden Fehler, Logs, Metriken und Timings. Die Fehler kommen mit Stack Trace an (in Delphi mit unit, Funktion und Zeile, auf Win32 und Win64), dank der Symbol-Map im Executable. Es funktioniert ab XE8. Unten findest du die Schritte und die Fenster. Ganz am Ende steht, was ich wirklich ausprobiert habe und was nicht.

Was in 1.90 neu ist

Zum ersten Mal lebt ExeWatch in der IDE. Die 1.90.0 (Delphi-SDK 0.25.0) hat ein einziges Setup und ein Menü in RAD Studio: Du wählst einen Eintrag, und das geöffnete Projekt hat die Telemetrie aktiv, mit der Symbol-Map im Executable für die Stack Traces. Für mich ist das das Release, das ExeWatch dorthin bringt, wo du ohnehin arbeitest, nämlich in dein Projekt. Ich zeige es live auf der ITDevCon 2026, in Rom am 19. und 20. November, und danach auch auf der EKON: Die Details stehen ganz unten.

Lade das Setup herunter und probiere es an einem eigenen Projekt aus. Unten findest du die Schritte, einen nach dem anderen, mit den Fenstern, die du in der IDE sehen wirst: Installation, Menü, Aktivierung der Telemetrie und am Ende ein Stack Trace.

Sieh dir vorab den ganzen Ablauf in gut einer Minute an: neues Projekt, ExeWatch über das Menü aktivieren, API-Key, Build und der Stack Trace, der in der Konsole ankommt. Das Video hat 1920×1080: Um die Details zu lesen, nutze die Vollbild-Schaltfläche des Players.

1. Das Setup installieren

Das Setup heißt ExeWatch for RAD Studio und wiegt etwa 2,9 MB. Es installiert pro Benutzer und verlangt keine Administratorrechte. Es macht Folgendes:

• Es integriert den Expert in die IDE jedes auf dem Rechner installierten RAD Studio, ab XE8;
• es kopiert die SDK-Quellen;
• es installiert das Kommandozeilenwerkzeug ExeWatchMapCLI.exe, das du in Build-Skripten und in der CI verwendest;
• es setzt die Umgebungsvariable EXEWATCH_SDK, die du danach im Library Path wiederfindest.

Du lädst es als ExeWatchRADStudioSetup.exe von der ExeWatch-Website herunter: Der Link ist auch der erste Schritt der Liste “Setup” im Delphi-Abschnitt der Startseite. Wenn du Delphi oder C++Builder in einer Version vor XE8 einsetzt oder eine andere Sprache verwendest, findest du auf der Startseite den Tab “DLL”.

2. Das ExeWatch-Menü öffnen

Öffne ein Projekt und gehe zu Project > ExeWatch. Dasselbe Menü gibt es auch im Kontextmenü des Projekts im Project Manager. Es enthält drei Einträge.

3. Enable ExeWatch Telemetry

Das ist der Eintrag, der dir die Handarbeit erspart. Du wählst ihn, und der Expert:

1. legt im Projekt ExeWatchConfig.pas an;
2. fügt dem Projekt die SDK-units hinzu (ExeWatchSDKv1, dazu die unit für VCL oder FMX);
3. trägt StartExeWatch und FlushExeWatch in die Hauptdatei ein: die .dpr in Delphi, die .cpp in C++Builder.

Am Ende erklärt dir ein Fenster, was getan wurde. Wenn du sehen willst, was sich in den Projektdateien geändert hat, hast du den Diff deines Versionsverwaltungssystems.

Dasselbe Fenster schaltet für dieses Projekt auch Link map file ein: Dazu kommen wir gleich.

Das ist die .dpr einer VCL-Testanwendung (PlainVcl) nach dem Klick, 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.

Und das ist die Zeile, die die IDE beim nächsten Build ins Messages-Fenster schreibt:

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

Der API-Schlüssel

In der generierten unit änderst du nur eine Konstante: EXEWATCH_API_KEY.

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

Den Schlüssel holst du dir aus der ExeWatch-Konsole. Die Seite API Keys der App zeigt dir schon den fertigen Code mit dem Schlüssel darin und einen Button “Copy the key”: kopieren und einfügen. Ein Windows-Schlüssel beginnt mit ew_win_.

Der customer

Der customer ist keine Konstante, die du ändern müsstest. Er sagt dir, für welchen Kunden die Anwendung gerade läuft, also liest du ihn aus der Lizenz (oder aus dem Login oder aus einer Einstellung). Du hast zwei Möglichkeiten, ihn an ExeWatch zu übergeben.

Wenn du ihn beim Start schon kennst, übergibst du ihn direkt an StartExeWatch:

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

Wenn du ihn erst später kennst, zum Beispiel nach dem Login, startest du ExeWatch ohne Parameter und übergibst ihn, sobald du ihn hast, mit SetExeWatchCustomer:

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

Der generierte Platzhalter ist customer-id, und ich habe ihn absichtlich so gelassen: Eine “einfache” Integration loggt trotzdem, und du merkst sofort, was du ändern musst.

4. Link map file

Das ist eine Option pro Projekt. Wenn sie eingeschaltet ist, wird die Symbol-Map am Ende des Builds ins Executable geschrieben, in eine PE-Sektion namens .ewmap. Beim Kunden muss keine .map-Datei neben der Exe ausgeliefert werden.

Die Alternative bleibt bestehen: Wenn du die .map lieber neben dem Executable behältst, funktioniert das weiterhin.

Ein Hinweis für alle, die ihre Executables mit Authenticode signieren: Die Map muss vor der Signatur geschrieben werden, denn die hinzugefügte Sektion macht eine bereits angebrachte Signatur ungültig.

5. Einen Fehler auslösen und den Stack Trace ansehen

Zum Ausprobieren habe ich PlainVcl benutzt, die VCL-Anwendung von vorhin, mit einem Button, der eine Bestellung speichert, und einer Prüfung, die fehlschlägt:

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;

Im Handler steht kein einziger Aufruf von ExeWatch: Die unbehandelte Exception eines OnClick fängt es von selbst ab. Es genügen StartExeWatch und FlushExeWatch in der .dpr, die das Menü eingetragen hat. Den customer ACME-Corp habe ich mit SetExeWatchCustomer im FormCreate des Formulars übergeben.

Du kompilierst, drückst den Button und öffnest die ExeWatch-Konsole. Im Log-Detail findest du die Exception, den customer und den Stack Trace:

Das sind die ersten Zeilen des Stack Trace, unter 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

Ganz oben steht dein Code, mit unit, Funktion und Zeile. Dann kommt die VCL, die den Klick bis zum Handler trägt. Danach folgen die System-Frames, also Namen von Funktionen, die Windows exportiert, und weitere WndProc: insgesamt 31 Frames, ich zeige die ersten. Auf 64 Bit kompiliert, liefert dasselbe Projekt denselben Weg: CheckTotals, SaveOrder, SaveButtonClick, dann Vcl.Controls.TControl.Click.

Die Konsole im Screenshot ist eine Testinstanz von ExeWatch 1.90, mit Testdaten.

Die Stack Traces, auf Win32 und auf Win64

Der Stack Trace ist eines der Werkzeuge, die ExeWatch dir neben Logs, Metriken und Timings gibt. Wenn eine Exception von einem Kunden kommt, ist er eines der nützlichsten, weil er dir sagt, wo sie ausgelöst wurde. Was du bekommst, hängt von der Sprache ab.

Delphi, Win32 und Win64, Debug und Release. Jede Exception kommt mit unit, Funktion und Zeilennummer an, und der Trace beginnt an der Stelle, an der die Exception ausgelöst wurde. Es funktioniert auch auf 32 Bit.

C++Builder. Das Menü ist dasselbe: Enable ExeWatch Telemetry fügt dem Projekt ExeWatchConfig.pas und die SDK-units hinzu und trägt StartExeWatch(); und FlushExeWatch(); in die Haupt-.cpp ein. Das Projekt kompiliert die SDK-units selbst, also gibt es keine DLL auszuliefern und keine Import-Library zu linken. Der Stack Trace enthält die Funktionsnamen, aber keine Zeilennummern, weil die Map des C++-Linkers sie nicht enthält. Eine mit throw aus C++ geworfene Exception kommt mit Meldung, Klasse, Breadcrumbs, Benutzer und Tags an, vorerst aber ohne Stack Trace, und unter Win64x werden die Namen nicht aufgelöst. Diesen Teil habe ich mit RAD Studio 12 und 13 geprüft.

Die SDK-DLL. Sie fängt die Exceptions ab, die in ihrem eigenen Code ausgelöst werden, und in einem Host, der dieselbe Delphi-Runtime verwendet. Ein Host mit einer anderen Runtime, etwa MSVC oder Python, bekommt für seine eigenen Exceptions keinen Stack Trace.

Nicht nur Stack Traces: die Gesundheit deiner Projekte beim Kunden

Der Stack Trace sagt dir, wo ein Fehler explodiert ist. Um zu wissen, wie es deinen Anwendungen bei den Kunden geht, braucht es mehr, und ExeWatch sammelt es an derselben Stelle:

• die Fehler, mit Stack Trace, gruppiert nach Problem, Version, customer und Gerät, damit du siehst, wer betroffen ist und seit wann;
• die Logs und die Metriken der Anwendungen;
• die Timings, auch verschachtelte, um zu verstehen, wohin die Zeit geht;
• die tatsächliche Nutzung der Anwendungen und die installierten Versionen bei jedem Kunden;
• einen KI-Agenten, der die Fehler über MCP und von der Kommandozeile liest, wie ich in Delphi, KAI und ExeWatchMCP: Was, wenn dein KI-Assistent die Fehler deiner Kunden liest und behebt? erzähle.

Für mich ist das die vollständigste Lösung, um die Gesundheit deiner Projekte beim Kunden im Blick zu behalten. Wenn du in Produktion schon ein Werkzeug einsetzt, das Exceptions abfängt und den Stack Trace erzeugt, ersetzt ExeWatch es nicht: Es gibt dir auch alles andere und verträgt sich mit dem, was du hast (ich habe darüber in ExeWatch in Delphi-Projekte integrieren, die bereits madExcept nutzen geschrieben). Du kannst mit einem kostenlosen Konto anfangen.

Von der Kommandozeile: ExeWatchMapCLI

Außerhalb der IDE (Build-Skripte, CI, ein KI-Agent) verlinkst du die Map mit ExeWatchMapCLI.exe, direkt nach dem Build, auf das Executable. Das Setup hat es bereits im Ordner bin installiert, und du kannst es in den PATH aufnehmen:

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

Die Map landet im Executable, genau wie beim Menü der IDE. Im Tab Command line des Playground gibt es außerdem einen fertigen Anweisungstext für einen KI-Agenten, mit den Build-Einstellungen, dem Befehl, der Art, das Ergebnis zu lesen, und dem, was bei jedem Fehler zu tun ist.

Das Playground

Der dritte Menüeintrag, Playground and updates…, öffnet ein Fenster mit vier Tabs.

Try your key. Du fügst den Schlüssel der Anwendung ein und drückst “Check the key”, das eine Debug-Zeile sendet, oder “Send sample logs”, das vier sendet (debug, info, warning, error). Die Antwort des Servers siehst du im Fenster. Alle tragen das Tag exewatch-ide-test und werden auf das Monatsvolumen des Kontos angerechnet.

Guide and AI. Die Verweise auf die Anleitung und die Befehle, mit denen ein KI-Agent die Fehler über den MCP-Server lesen kann. Wenn du nicht weißt, wovon ich rede: Ich habe darüber in Delphi, KAI und ExeWatchMCP: Was, wenn dein KI-Assistent die Fehler deiner Kunden liest und behebt? geschrieben.

Command line. Die von oben.

SDK and updates. Die installierte Version, die neueste verfügbare, die Dringlichkeit des Updates und was sich geändert hat.

Von XE8 bis 13

Die Support-Aussage lautet XE8 und neuer. Hier steht, was ich wirklich ausprobiert habe und was nicht:

• die Integration in die IDE habe ich live in XE8 und in Delphi 13 ausprobiert;
• die IDE-Schicht kompiliert unter XE8, 12 und 13;
• das native SDK kompiliert von XE8 bis 13, Win32 und Win64, und im Cross-Compile für Linux64 mit Delphi 13;
• seit diesem Release läuft die Testsuite des SDK auch unter XE8, zusätzlich zu 12 und 13.

Die Versionen dazwischen habe ich nicht einzeln ausprobiert, und das sage ich dir lieber offen.

Live: Ich freue mich auf dich bei der ITDevCon 2026

ITDevCon 2026, Rom, 19. und 20. November. Hier zeige ich dir ExeWatch for RAD Studio live, mit der Integration in die IDE: das Setup, das Menü, den Stack Trace, der in der Konsole ankommt. Bring ein eigenes Projekt mit und die Fragen, die du hast. Tickets gibt es hier, die Website ist itdevcon.it.

Die Vorträge, in denen ExeWatch vorkommt, beide im Saal Kirk:

• KAI + ExeWatch: il mondo Delphi non sarà più lo stesso (KAI + ExeWatch: Die Delphi-Welt wird nie mehr dieselbe sein), von 10:35 bis 11:30 Uhr;
• ExeWatch: 500 persone stanno usando il tuo software in questo momento. Un crash report non ti dirà come sta andando. (ExeWatch: 500 Personen nutzen deine Software gerade in diesem Moment. Ein Crash-Report sagt dir nicht, wie es läuft.), von 15:05 bis 16:00 Uhr.

Das Programm mit allen meinen Vorträgen steht auf meiner Sprecherseite der ITDevCon.

Ich bringe es auch zur EKON 30, der Jubiläumsausgabe, Meliá Düsseldorf, vom 23. bis 27. November 2026. Tickets gibt es hier, und hier ist meine Seite bei den Sprechern.

Probier es an einem eigenen Projekt aus

Lade das Setup herunter, öffne ein Projekt, das du schon hast, und wähle Project > ExeWatch > Enable ExeWatch Telemetry. Dann logge großzügig: Je mehr ExeWatch sieht, desto nützlicher ist es dir, wenn ein Kunde anruft. Wenn du sehen willst, was sich mit den eintreffenden Daten anfangen lässt, habe ich über Updates und die tatsächliche Nutzung deiner Anwendungen und über verschachtelte Timings geschrieben. Alles Weitere steht auf exewatch.com.

Häufige Fragen

Was ist ExeWatch for RAD Studio? Es ist das Setup von ExeWatch 1.90, das der IDE von Delphi und C++Builder ein Menü hinzufügt, um die Telemetrie in einem Projekt zu aktivieren und die Symbol-Map mit dem Executable zu verlinken.

Ab welcher RAD-Studio-Version funktioniert es? Ab XE8. Die Integration wurde live in der IDE von XE8 und Delphi 13 ausprobiert; die IDE-Schicht kompiliert unter XE8, 12 und 13.

Brauche ich Administratorrechte? Nein. Das Setup installiert pro Benutzer.

Funktioniert der Stack Trace auf Win32 und auf Win64? Ja, in Delphi: unit, Funktion und Zeilennummer, Debug und Release. Was er in C++Builder macht, steht in einem eigenen Absatz im Artikel.

Muss ich eine .map-Datei zusammen mit dem Executable ausliefern? Nein, wenn die Map im Executable verlinkt ist (Option “Link map file”, PE-Sektion .ewmap). Die .map neben der Exe bleibt als Alternative.

Wo setze ich den customer? Er ist keine Konstante: Du liest ihn aus der Lizenz des Kunden und übergibst ihn direkt an StartExeWatch('ACME-Corp') oder später mit SetExeWatchCustomer. Der generierte Platzhalter ist customer-id.

Wo sehe ich es live? Vor allem auf der ITDevCon 2026 (Rom, 19. und 20. November): Daniele Teti zeigt es dort live. Er bringt es auch zur EKON 30 (Düsseldorf, 23. bis 27. November).