O ExeWatch agora gera o stack trace completo para Delphi Win32 e Win64 e tem um novo plugin para o RAD Studio

Você tem um projeto Delphi ou C++Builder rodando nos clientes e gostaria de saber o que acontece com ele, mas toda vez que abre a página do SDK lembra de tudo o que precisa configurar. Com o ExeWatch 1.90 tentei fazer tudo a partir de um menu do IDE. Conto o que há dentro do novo setup e o que testei de verdade.

TL;DR: O ExeWatch 1.90 tem um setup chamado ExeWatch for RAD Studio que adiciona um menu ao IDE. Por ele você ativa a telemetria em um projeto Delphi ou C++Builder e recebe dos seus clientes erros, logs, métricas e timings. Os erros chegam com o stack trace (no Delphi com unit, função e linha, em Win32 e Win64) graças ao mapa de símbolos dentro do executável. Funciona do XE8 em diante. Abaixo estão os passos e as janelas. No final você vê o que testei de verdade e o que não.

O que há de novo na 1.90

Pela primeira vez o ExeWatch vive dentro do IDE. A 1.90.0 (SDK Delphi 0.25.0) tem um setup único e um menu no RAD Studio: você escolhe uma opção e o projeto que está aberto passa a ter a telemetria ativa, com o mapa de símbolos dentro do executável para os stack traces. Para mim é a release que coloca o ExeWatch onde você já está trabalhando, no seu projeto. Eu a mostro ao vivo na ITDevCon 2026, em Roma, nos dias 19 e 20 de novembro, e depois também na EKON: os detalhes estão no final.

Baixe o setup e experimente em um projeto seu. Abaixo estão os passos, um de cada vez, com as janelas que você verá no IDE: instalação, menu, ativação da telemetria e, no fim, um stack trace.

Antes de começar, veja todo o caminho em pouco mais de um minuto: projeto novo, ExeWatch ativado pelo menu, chave de API, build e o stack trace chegando ao console. O vídeo está em 1920×1080: para ler os detalhes, use o botão de tela cheia do player.

1. Instale o setup

O setup se chama ExeWatch for RAD Studio e pesa cerca de 2,9 MB. Ele instala por usuário e não pede direitos de administrador. O que ele faz:

• integra o expert no IDE de cada RAD Studio instalado na máquina, do XE8 em diante;
• copia os fontes do SDK;
• instala a ferramenta de linha de comando ExeWatchMapCLI.exe, a que você usa nos scripts de build e na CI;
• define a variável de ambiente EXEWATCH_SDK, que depois você encontra no Library Path.

Você baixa o ExeWatchRADStudioSetup.exe no site do ExeWatch: o link também é o primeiro passo da lista “Setup” na seção Delphi da home. Se você tem um Delphi ou C++Builder anterior ao XE8, ou usa outra linguagem, na home há a aba “DLL”.

2. Abra o menu ExeWatch

Abra um projeto e vá em Project > ExeWatch. O mesmo menu também está no menu de contexto do projeto no Project Manager. Ele tem três opções.

3. Enable ExeWatch Telemetry

É a opção que poupa o trabalho manual. Você a escolhe e o expert:

1. cria no projeto o ExeWatchConfig.pas;
2. adiciona ao projeto as units do SDK (ExeWatchSDKv1, mais a unit para VCL ou FMX);
3. insere StartExeWatch e FlushExeWatch no arquivo principal: o .dpr no Delphi, o .cpp no C++Builder.

No final, uma janela explica o que foi feito. Se quiser ver o que mudou nos arquivos do projeto, use o diff do seu sistema de controle de versão.

A mesma janela também liga o Link map file para aquele projeto: já chegamos nele.

Este é o .dpr de uma aplicação VCL de teste (PlainVcl) depois do clique, no 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 esta é a linha que o IDE escreve na janela Messages no build seguinte:

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

A chave de API

Na unit gerada você muda uma única constante: EXEWATCH_API_KEY.

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

A chave você pega no console do ExeWatch. A página API Keys do app já mostra o código pronto com a chave dentro e um botão “Copy the key”: é só copiar e colar. Uma chave Windows começa com ew_win_.

O customer

O customer não é uma constante a modificar. Ele diz para qual cliente a aplicação está rodando, então você o lê da licença (ou do login, ou de uma configuração). Há duas maneiras de informá-lo ao ExeWatch.

Se você já o conhece na inicialização, passa direto para StartExeWatch:

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

Se só o conhece mais tarde, por exemplo depois do login, inicia o ExeWatch sem parâmetros e o passa quando o tiver, com SetExeWatchCustomer:

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

O placeholder gerado é customer-id, e deixei assim de propósito: uma integração “básica” já registra logs mesmo assim, e você percebe na hora o que precisa mudar.

4. Link map file

É uma opção por projeto. Quando está ligada, no fim do build o mapa de símbolos é gravado dentro do executável, em uma seção PE chamada .ewmap. O cliente não precisa distribuir nenhum .map junto do exe.

A alternativa continua valendo: se você prefere manter o .map ao lado do executável, ele ainda funciona.

Um aviso para quem assina os executáveis com Authenticode: o mapa precisa ser gravado antes da assinatura, porque a seção adicionada invalida uma assinatura já aplicada.

5. Provoque um erro e olhe o stack trace

Para testar usei o PlainVcl, a aplicação VCL de antes, com um botão que salva um pedido e uma verificação que falha:

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;

No handler não há nenhuma chamada ao ExeWatch: a exceção não tratada de um OnClick ele captura sozinho. Bastam StartExeWatch e FlushExeWatch no .dpr, que o menu colocou. O customer ACME-Corp eu passei com SetExeWatchCustomer no FormCreate do form.

Você compila, aperta o botão e abre o console do ExeWatch. No detalhe do log aparecem a exceção, o customer e o stack trace:

Estas são as primeiras linhas do stack trace, em 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

No topo está o seu código, com unit, função e linha. Depois vem a VCL, que leva o clique até o handler. Em seguida aparecem os frames de sistema, que são nomes de funções exportadas pelo Windows, e outras WndProc: ao todo 31 frames, eu mostro os primeiros. Compilado em 64 bits, o mesmo projeto dá o mesmo caminho: CheckTotals, SaveOrder, SaveButtonClick, depois Vcl.Controls.TControl.Click.

O console da captura de tela é uma instância de teste do ExeWatch 1.90, com dados de teste.

Os stack traces, em Win32 e em Win64

O stack trace é uma das ferramentas que o ExeWatch oferece, ao lado de logs, métricas e timings. Quando uma exceção chega de um cliente, é uma das mais úteis, porque diz onde ela foi lançada. O que você obtém depende da linguagem.

Delphi, Win32 e Win64, Debug e Release. Cada exceção chega com unit, função e número de linha, e o stack trace começa no ponto em que a exceção foi lançada. Funciona também em 32 bits.

C++Builder. O menu é o mesmo: Enable ExeWatch Telemetry adiciona ao projeto o ExeWatchConfig.pas e as units do SDK e insere StartExeWatch(); e FlushExeWatch(); no .cpp principal. O projeto compila sozinho as units do SDK, então não há DLL para distribuir nem import library para linkar. O stack trace tem os nomes das funções mas não os números de linha, porque o map do linker C++ não os contém. Uma exceção lançada com throw a partir do C++ chega com mensagem, classe, breadcrumb, usuário e tag, mas por ora sem stack trace, e em Win64x os nomes não são resolvidos. Essa parte eu verifiquei com o RAD Studio 12 e 13.

A DLL do SDK. Ela captura as exceções lançadas no próprio código e em um host que usa o mesmo runtime Delphi. Um host com outro runtime, como MSVC ou Python, não obtém o stack trace das próprias exceções.

Não só stack trace: a saúde dos seus projetos no cliente

O stack trace diz onde um erro explodiu. Para saber como estão as suas aplicações nos clientes é preciso mais, e o ExeWatch coleta isso no mesmo lugar:

• os erros, com o stack trace, agrupados por problema, versão, customer e device, para você ver quem é afetado e desde quando;
• os logs e as métricas das aplicações;
• os timings, inclusive aninhados, para entender para onde vai o tempo;
• o uso real das aplicações e as versões instaladas em cada cliente;
• um agente de IA que lê os erros via MCP e pela linha de comando, como conto em ExeWatchMCP, KAI e a produção dos seus clientes.

Para mim é a solução mais completa para acompanhar a saúde dos seus projetos no cliente. Se em produção você já usa uma ferramenta que captura as exceções e produz o stack trace, o ExeWatch não a substitui: ele oferece também todo o resto e convive com o que você já tem (escrevi sobre isso em ExeWatch e madExcept juntos). Você pode começar com uma conta gratuita.

Pela linha de comando: ExeWatchMapCLI

Fora do IDE (scripts de build, CI, um agente de IA) o mapa é ligado com o ExeWatchMapCLI.exe, logo depois do build, sobre o executável. O setup já o instalou na pasta bin e você pode colocá-lo no PATH:

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

O mapa vai parar dentro do executável, como no menu do IDE. Na aba Command line do Playground há também um texto de instruções pronto para entregar a um agente de IA, com as configurações de build, o comando, como ler o resultado e o que fazer a cada erro.

O Playground

A terceira opção do menu, Playground and updates…, abre uma janela com quatro abas.

Try your key. Você cola a chave da aplicação e aperta “Check the key”, que envia uma linha de debug, ou “Send sample logs”, que envia quatro (debug, info, warning, error). A resposta do servidor aparece na janela. Todas levam a tag exewatch-ide-test e contam no volume mensal da conta.

Guide and AI. Os links para o guia e os comandos para fazer um agente de IA ler os erros por meio do servidor MCP. Se você não sabe do que estou falando, escrevi sobre isso em ExeWatchMCP, KAI e a produção dos seus clientes.

Command line. A de que falei acima.

SDK and updates. A versão instalada, a última disponível, a urgência da atualização e o que mudou.

Do XE8 ao 13

A declaração de suporte é XE8 e posteriores. Isto é o que testei de verdade e o que não:

• a integração no IDE eu testei ao vivo no XE8 e no Delphi 13;
• a camada IDE compila no XE8, 12 e 13;
• o SDK nativo compila do XE8 ao 13, Win32 e Win64, e em cross-compile Linux64 com o Delphi 13;
• a partir desta release a suíte de testes do SDK roda também no XE8, além do 12 e do 13.

As versões intermediárias eu não testei uma a uma, e prefiro deixar isso claro.

Ao vivo: espero você na ITDevCon 2026

ITDevCon 2026, Roma, 19 e 20 de novembro. É o lugar onde mostro o ExeWatch for RAD Studio ao vivo, com a integração no IDE: o setup, o menu, o stack trace que chega no console. Traga um projeto seu e as perguntas que quiser. Ingressos aqui, o site é itdevcon.it.

As palestras em que o ExeWatch aparece, ambas na Sala Kirk:

• KAI + ExeWatch: il mondo Delphi non sarà più lo stesso (KAI + ExeWatch: o mundo Delphi não será mais o mesmo), das 10h35 às 11h30;
• ExeWatch: 500 persone stanno usando il tuo software in questo momento. Un crash report non ti dirà come sta andando. (ExeWatch: 500 pessoas estão usando o seu software neste momento. Um crash report não vai dizer como está indo.), das 15h05 às 16h00.

O programa com todas as minhas palestras está na minha página entre os palestrantes da ITDevCon.

Levo o ExeWatch também à EKON 30, a edição de 30 anos, Meliá Düsseldorf, de 23 a 27 de novembro de 2026. Ingressos aqui, e a minha página entre os palestrantes.

Experimente em um projeto seu

Baixe o setup, abra um projeto que você já tem e escolha Project > ExeWatch > Enable ExeWatch Telemetry. Depois registre logs sem medo de exagerar: quanto mais o ExeWatch vê, mais útil ele é quando um cliente liga. Se quiser ver o que dá para fazer com os dados que chegam, escrevi sobre as atualizações e o uso real das suas aplicações e sobre os timings aninhados. Tudo o mais está em exewatch.com.

Perguntas frequentes

O que é o ExeWatch for RAD Studio? É o setup do ExeWatch 1.90 que adiciona um menu ao IDE do Delphi e do C++Builder para ativar a telemetria em um projeto e ligar o mapa de símbolos ao executável.

A partir de qual versão do RAD Studio funciona? Do XE8 em diante. A integração foi testada ao vivo no IDE do XE8 e do Delphi 13; a camada IDE compila no XE8, 12 e 13.

Preciso de direitos de administrador? Não. O setup instala por usuário.

O stack trace funciona em Win32 e em Win64? Sim, no Delphi: unit, função e número de linha, Debug e Release. O que ele faz no C++Builder está explicado em um parágrafo à parte no artigo.

Preciso distribuir um arquivo .map junto com o executável? Não, se o mapa estiver ligado ao executável (opção “Link map file”, seção PE .ewmap). O .map ao lado do exe continua disponível como alternativa.

Onde coloco o customer? Não é uma constante: você o lê da licença do cliente e o passa direto para StartExeWatch('ACME-Corp'), ou mais tarde com SetExeWatchCustomer. O placeholder gerado é customer-id.

Onde posso ver isso ao vivo? Principalmente na ITDevCon 2026 (Roma, 19 e 20 de novembro): Daniele Teti mostra o ExeWatch ao vivo lá. Ele também o leva à EKON 30 (Düsseldorf, de 23 a 27 de novembro).