ExeWatch ahora genera el stack trace completo para Delphi Win32 y Win64 y tiene un nuevo plugin para RAD Studio

Tienes un proyecto Delphi o C++Builder que corre en casa de tus clientes y te gustaría saber qué les pasa, pero cada vez que abres la página del SDK te viene a la cabeza todo lo que hay que configurar. Con ExeWatch 1.90 he intentado hacerlo todo desde un menú del IDE. Te cuento qué hay dentro del nuevo setup y qué he probado de verdad.

TL;DR: ExeWatch 1.90 tiene un setup que se llama ExeWatch for RAD Studio y añade un menú al IDE. Desde ahí activas la telemetría en un proyecto Delphi o C++Builder y recibes de tus clientes errores, logs, métricas y timing. Los errores llegan con su stack trace (en Delphi con unit, función y línea, en Win32 y Win64) gracias al mapa de símbolos dentro del ejecutable. Funciona desde XE8 en adelante. Más abajo encuentras los pasos y las ventanas. Al final encuentras qué he probado de verdad y qué no.

Qué hay de nuevo en la 1.90

Por primera vez ExeWatch vive dentro del IDE. La 1.90.0 (SDK Delphi 0.25.0) trae un setup único y un menú en RAD Studio: eliges una entrada y el proyecto que tienes abierto tiene la telemetría activa, con el mapa de símbolos dentro del ejecutable para los stack traces. Para mí es la release que pone ExeWatch donde ya estás trabajando, sobre tu proyecto. Lo muestro en vivo en ITDevCon 2026, en Roma el 19 y 20 de noviembre, y después también en EKON: los detalles están al final.

Descarga el setup y pruébalo en un proyecto tuyo. Aquí abajo tienes los pasos, uno a uno, con las ventanas que verás en el IDE: instalación, menú, activación de la telemetría y, al final, un stack trace.

Antes de empezar, mira todo el recorrido en poco más de un minuto: proyecto nuevo, ExeWatch activado desde el menú, clave API, compilación y el stack trace que llega a la consola. El vídeo es de 1920×1080: para leer los detalles, usa el botón de pantalla completa del reproductor.

1. Instala el setup

El setup se llama ExeWatch for RAD Studio y pesa unos 2,9 MB. Instala por usuario y no pide derechos de administrador. Qué hace:

• integra el expert en el IDE de cada RAD Studio instalado en la máquina, desde XE8 en adelante;
• copia las fuentes del SDK;
• instala la herramienta de línea de comandos ExeWatchMapCLI.exe, la que usas en los scripts de build y en la CI;
• define la variable de entorno EXEWATCH_SDK, que es la que luego encuentras en el Library Path.

Lo descargas desde ExeWatchRADStudioSetup.exe, en el sitio de ExeWatch: el enlace es también el primer paso de la lista “Setup” en la sección Delphi de la home. Si tienes un Delphi o un C++Builder anteriores a XE8, o usas otro lenguaje, en la home está la pestaña “DLL”.

2. Abre el menú ExeWatch

Abre un proyecto y ve a Project > ExeWatch. El mismo menú está también en el menú contextual del proyecto en el Project Manager. Contiene tres entradas.

3. Enable ExeWatch Telemetry

Es la entrada que te ahorra el trabajo a mano. La eliges, y el expert:

1. crea en el proyecto ExeWatchConfig.pas;
2. añade al proyecto las units del SDK (ExeWatchSDKv1, más la unit para VCL o FMX);
3. inserta StartExeWatch y FlushExeWatch en el archivo principal: el .dpr en Delphi, el .cpp en C++Builder.

Al final una ventana te explica qué ha hecho el expert. Si quieres ver qué ha cambiado en los archivos del proyecto, tienes el diff de tu sistema de control de versiones.

La misma ventana activa también Link map file para ese proyecto: enseguida volvemos a ella.

Este es el .dpr de una aplicación VCL de prueba (PlainVcl) después del clic, en 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.

Y esta es la línea que el IDE escribe en la ventana Messages en la build siguiente:

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

La clave de API

En la unit generada cambias una sola constante: EXEWATCH_API_KEY.

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

La clave la tomas de la consola de ExeWatch. La página API Keys de la app ya te muestra el código listo con la clave dentro y un botón “Copy the key”: copias y pegas. Una clave de Windows empieza por ew_win_.

El customer

El customer no es una constante que haya que modificar. Te dice para qué cliente está corriendo la aplicación, así que lo lees de la licencia (o del login, o de una configuración). Tienes dos maneras de dárselo a ExeWatch.

Si ya lo conoces al arrancar, se lo pasas directamente a StartExeWatch:

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

Si lo conoces más tarde, por ejemplo después del login, arrancas ExeWatch sin parámetros y se lo pasas cuando lo tengas, con SetExeWatchCustomer:

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

El marcador generado es customer-id, y lo he dejado así a propósito: una integración “básica” registra igualmente, y te das cuenta enseguida de qué tienes que cambiar.

4. Link map file

Es una opción por proyecto. Cuando está activa, al final de la build el mapa de símbolos se escribe dentro del ejecutable, en una sección PE llamada .ewmap. El cliente no tiene que distribuir ningún .map junto al exe.

La alternativa sigue ahí: si prefieres tener el .map junto al ejecutable, sigue funcionando.

Una cosa para quien firma sus ejecutables con Authenticode: el mapa hay que escribirlo antes de la firma, porque la sección añadida invalida una firma ya aplicada.

5. Provoca un error y mira el stack trace

Para probarlo he usado PlainVcl, la aplicación VCL de antes, con un botón que guarda un pedido y una comprobación que falla:

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;

En el manejador no hay ninguna llamada a ExeWatch: la excepción no gestionada de un OnClick la captura él solo. Bastan StartExeWatch y FlushExeWatch en el .dpr, que ha puesto el menú. El customer ACME-Corp lo he pasado con SetExeWatchCustomer en el FormCreate del form.

Compilas, pulsas el botón y abres la consola de ExeWatch. En el detalle del log encuentras la excepción, el customer y el stack trace:

Estas son las primeras líneas del 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

Arriba está tu código, con unit, función y línea. Después viene la VCL, que lleva el clic hasta el manejador. Luego están los frames de sistema, que son nombres de funciones exportadas por Windows, y más WndProc: en total 31 frames, yo muestro los primeros. Compilado a 64 bits, el mismo proyecto da el mismo recorrido: CheckTotals, SaveOrder, SaveButtonClick, después Vcl.Controls.TControl.Click.

La consola de la captura es una instancia de prueba de ExeWatch 1.90, con datos de prueba.

Los stack traces, en Win32 y en Win64

El stack trace es una de las herramientas que ExeWatch te da, junto a logs, métricas y timing. Cuando una excepción llega desde un cliente, es de las más útiles, porque te dice dónde se produjo. Lo que obtienes depende del lenguaje.

Delphi, Win32 y Win64, Debug y Release. Cada excepción llega con unit, función y número de línea, y la traza parte del punto en el que se produjo la excepción. Funciona también en 32 bits.

C++Builder. El menú es el mismo: Enable ExeWatch Telemetry añade al proyecto ExeWatchConfig.pas y las units del SDK e inserta StartExeWatch(); y FlushExeWatch(); en el .cpp principal. El proyecto compila por sí solo las units del SDK, así que no hay DLL que distribuir ni import library que enlazar. El stack trace tiene los nombres de función pero no los números de línea, porque el map del linker de C++ no los contiene. Una excepción lanzada con throw desde C++ llega con mensaje, clase, breadcrumb, usuario y tag, pero por ahora sin stack trace, y en Win64x los nombres no se resuelven. Esta parte la he verificado con RAD Studio 12 y 13.

La DLL del SDK. Captura las excepciones producidas en su propio código y en un host que usa el mismo runtime de Delphi. Un host con otro runtime, como MSVC o Python, no obtiene el stack trace de sus propias excepciones.

No solo stack traces: la salud de tus proyectos en casa del cliente

El stack trace te dice dónde ha explotado un error. Para saber cómo están tus aplicaciones en casa de los clientes hace falta algo más, y ExeWatch lo recoge en el mismo sitio:

• los errores, con su stack trace, agrupados por problema, versión, customer y device, para que veas a quién afecta y desde cuándo;
• los logs y las métricas de las aplicaciones;
• los timings, también anidados, para entender dónde se va el tiempo;
• el uso real de las aplicaciones y las versiones instaladas en cada cliente;
• un agente de IA que lee los errores vía MCP y desde la línea de comandos, como cuento en ExeWatchMCP, KAI y la producción de tus clientes.

Para mí es la solución más completa para tener bajo control la salud de tus proyectos en casa del cliente. Si en producción ya usas una herramienta que captura las excepciones y produce el stack trace, ExeWatch no la sustituye: te da también todo lo demás, y convive con lo que ya tienes (lo conté en ExeWatch y madExcept juntos). Puedes empezar con una cuenta gratuita.

Desde la línea de comandos: ExeWatchMapCLI

Fuera del IDE (scripts de build, CI, un agente de IA) el mapa se enlaza con ExeWatchMapCLI.exe, justo después de la build, sobre el ejecutable. El setup ya lo ha instalado en la carpeta bin y puedes ponerlo en el PATH:

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

El mapa acaba en el ejecutable, igual que con el menú del IDE. En la pestaña Command line del Playground hay también un texto de instrucciones listo para dárselo a un agente de IA, con los ajustes de build, el comando, cómo leer el resultado y qué hacer ante cada error.

El Playground

La tercera entrada del menú, Playground and updates…, abre una ventana con cuatro pestañas.

Try your key. Pegas la clave de la aplicación y pulsas “Check the key”, que envía una línea de debug, o “Send sample logs”, que envía cuatro (debug, info, warning, error). Ves la respuesta del servidor en la ventana. Todas llevan el tag exewatch-ide-test y cuentan en el volumen mensual de la cuenta.

Guide and AI. Los enlaces a la guía y los comandos para que un agente de IA lea los errores a través del servidor MCP. Si no sabes de qué hablo, lo conté en ExeWatchMCP, KAI y la producción de tus clientes.

Command line. La de arriba.

SDK and updates. La versión instalada, la última disponible, la urgencia de la actualización y qué ha cambiado.

De XE8 a 13

La declaración de soporte es XE8 y posteriores. Esto es lo que he probado de verdad y lo que no:

• la integración en el IDE la he probado en vivo en XE8 y en Delphi 13;
• la capa IDE compila en XE8, 12 y 13;
• el SDK nativo compila de XE8 a 13, Win32 y Win64, y en cross-compile Linux64 con Delphi 13;
• desde esta release la suite de tests del SDK corre también en XE8, además de en 12 y 13.

Las versiones intermedias no las he probado una a una, y prefiero decírtelo.

En vivo: te espero en ITDevCon 2026

ITDevCon 2026, Roma, 19 y 20 de noviembre. Es el sitio donde te enseño ExeWatch for RAD Studio en vivo, con la integración en el IDE: el setup, el menú, el stack trace que llega a la consola. Trae un proyecto tuyo y las preguntas que quieras. Entradas aquí, el sitio es itdevcon.it.

Las charlas en las que aparece ExeWatch, ambas en la Sala Kirk:

• KAI + ExeWatch: il mondo Delphi non sarà più lo stesso (KAI + ExeWatch: the Delphi world will never be the same), de 10:35 a 11:30;
• ExeWatch: 500 persone stanno usando il tuo software in questo momento. Un crash report non ti dirà come sta andando. (ExeWatch: 500 people are using your software right now. A crash report will not tell you how it is going.), de 15:05 a 16:00.

El programa con todas mis charlas está en mi página entre los ponentes de ITDevCon.

También lo llevo a EKON 30, la edición del trigésimo aniversario, Meliá Düsseldorf, del 23 al 27 de noviembre de 2026. Entradas aquí, y mi página entre los ponentes.

Pruébalo en un proyecto tuyo

Descarga el setup, abre un proyecto que ya tengas y elige Project > ExeWatch > Enable ExeWatch Telemetry. Después registra sin escatimar: cuanto más ve ExeWatch, más útil te resulta cuando un cliente llama por teléfono. Si quieres ver qué se puede hacer con los datos que llegan, he escrito sobre las actualizaciones y el uso real de tus aplicaciones y sobre los timings anidados. Todo lo demás está en exewatch.com.

Preguntas frecuentes

¿Qué es ExeWatch for RAD Studio? Es el setup de ExeWatch 1.90 que añade un menú al IDE de Delphi y C++Builder para activar la telemetría en un proyecto y enlazar el mapa de símbolos al ejecutable.

¿Desde qué versión de RAD Studio funciona? Desde XE8 en adelante. La integración se ha probado en vivo en el IDE de XE8 y de Delphi 13; la capa IDE compila en XE8, 12 y 13.

¿Hacen falta derechos de administrador? No. El setup instala por usuario.

¿El stack trace funciona en Win32 y en Win64? Sí, en Delphi: unit, función y número de línea, Debug y Release. Lo que hace en C++Builder se explica en un apartado aparte del artículo.

¿Tengo que distribuir un archivo .map junto con el ejecutable? No, si el mapa está enlazado en el ejecutable (opción “Link map file”, sección PE .ewmap). El .map junto al exe sigue disponible como alternativa.

¿Dónde pongo el customer? No es una constante: lo lees de la licencia del cliente y se lo pasas directamente a StartExeWatch('ACME-Corp'), o más tarde con SetExeWatchCustomer. El marcador generado es customer-id.

¿Dónde lo puedo ver en vivo? Sobre todo en ITDevCon 2026 (Roma, 19 y 20 de noviembre): Daniele Teti lo muestra en vivo allí. También lo lleva a EKON 30 (Düsseldorf, del 23 al 27 de noviembre).