ExeWatch 1.8: .NET SDK for WPF and WinForms, Custom Metrics, Health Monitoring and On Premise

TL;DR: ExeWatch 1.8 is a major step forward: the .NET/C# SDK (WPF, WinForms, services), custom metrics with time-series charts, automatic health monitoring with notifications, read-only application sharing and — by popular demand — on premise deployment. Try it at exewatch.com

ExeWatch Beyond Delphi

When I first introduced ExeWatch, I described it as a monitoring tool for Delphi applications. That was true, but it was also a partial view. The fundamentals ExeWatch provides — structured logging, timing, breadcrumbs, device info, anomaly detection — are not language-specific. They are universal needs for anyone building software that runs “outside the browser”, where production logs have historically been hard to obtain.

In recent weeks we received concrete requests from teams developing in C# who were looking for something with the same characteristics as ExeWatch but for the .NET world. Not generic APM tools designed for cloud microservices, but something targeted at desktop applications, Windows services, WPF and WinForms.

Instead of saying “that’s not our target”, we wrote the SDK.

.NET / C# SDK

The .NET SDK is now available with feature parity to the Delphi one. It supports .NET 8.0+ on Windows and covers all common scenarios:

• Console, WPF, WinForms, Windows Service — a single base package, plus an optional WinForms hook (ExeWatch.WinForms) that captures UI thread exceptions
• Zero NuGet dependencies — just like the Delphi SDK, no external dependencies
• Same API — anyone familiar with the Delphi SDK will feel right at home
• Offline persistence — logs are saved to disk before sending, with automatic retry
• Server-side configuration — flush interval, batch size and sampling rate controllable from the dashboard without redeploying the application

Initialization is identical to Delphi:

using ExeWatch;

ExeWatchSdk.Initialize(new ExeWatchConfig
{
    ApiKey = "ew_win_your_key",
    CustomerId = "ACME-Corp"
});

EW.Info("Application started", "startup");

From that point on, the API is the same. Timing, breadcrumbs, metrics:

// Timing with category
EW.StartTiming("invoice.generate", "pdf");
// ... generate the PDF ...
EW.EndTiming("invoice.generate");

// Breadcrumb to trace the user path
EW.AddBreadcrumb("Clicked Export", "ui");

// Counter and gauge
EW.IncrementCounter("invoices.generated", 1);
EW.RecordGauge("queue.size", pendingJobs.Count);

For WinForms, just add one line to capture UI thread exceptions:

using ExeWatch;
using ExeWatch.WinForms;

ExeWatchSdk.Initialize(config);
ExeWatchWinForms.Install();  // captures Application.ThreadException

The samples repository includes three complete .NET samples: a console app, an interactive WinForms application and a Windows Service.

Custom Metrics

Until the previous version, ExeWatch collected metrics (counters and gauges) but only showed them as aggregate values. With 1.8, metrics have a dedicated page with time-series charts.

In practice, this means you can track domain-specific quantities and visualize them over time alongside logs and timings:

// Delphi — track business metrics
EW.IncrementCounter('orders.processed', 1);
EW.IncrementCounter('orders.failed', 1);
EW.RecordGauge('queue.pending', FPendingQueue.Count);

// Periodic gauge — sampled automatically every 30 seconds
EW.RegisterPeriodicGauge('memory_mb',
  function: Double
  begin
    Result := GetCurrentMemoryMB;
  end);

// C# — same API
EW.IncrementCounter("orders.processed", 1);
EW.RecordGauge("connections.active", pool.ActiveCount);

From the Metrics page you can also delete a specific metric’s data directly from the detail modal — useful during development or to clean up test data.

Health Monitoring

One of the most frequent questions we received was: “How do I know if my application is doing well without checking the dashboard every 5 minutes?”

The answer is health monitoring. Every application now has a Health Score calculated automatically based on three parameters: error rate, crashes and slow operations over the last 24 hours. The resulting status is one of Healthy, Degraded or Unhealthy.

The system includes anti-flapping logic: a single error is not enough to trigger a state change. This prevents unnecessary notifications and reduces noise.

When the health status changes, ExeWatch sends notifications via email and, if configured, via Discord through webhooks. Discord was added because many teams use it as an operational channel and prefer to receive notifications where they already work.

The level of detail in health monitoring depends on the plan: the Hobby plan offers basic monitoring, Pro adds error-based monitoring, Business includes full analysis with timing and trends.

Application Sharing

A feature we hadn’t planned but that was requested by several users: the ability to share an application in read-only mode with external users.

The typical scenario: you have a client who wants to see the status of their installation without you having to send them screenshots or periodic reports. With read-only sharing, you give them direct access to their application’s dashboard — logs, timing, health — without granting modification permissions or access to other applications in the account.

DMVCFramework Integration

For those developing server applications with DMVCFramework, we published a complete sample showing how to integrate ExeWatch into a TemplatePro + HTMX web application.

The integration leverages two mechanisms that DMVCFramework offers natively. The first is the LoggerPro callback appender: all LogI, LogW, LogE calls from the framework — including internal ones — are automatically forwarded to ExeWatch.

SetDefaultLogger(
  CreateLogBuilderWithDefaultConfiguration
    .WriteToCallback
    .WithCallback(
      procedure(const ALogItem: TLogItem; const AFormattedMessage: string)
      begin
        if ExeWatchIsInitialized and (ALogItem.LogType > TLogType.Debug) then
          EW.Log(
            TEWLogLevel(Ord(ALogItem.LogType)),
            ALogItem.LogMessage,
            ALogItem.LogTag,
            ALogItem.TimeStamp,
            ALogItem.ThreadID);
      end).Done.Build);

The second is DMVCFramework’s built-in profiler. Since the logger is already connected to ExeWatch, the timing of every controller action is tracked automatically:

Profiler.ProfileLogger := Log;
Profiler.WarningThreshold := 500;           // warn if action > 500ms
Profiler.LogsOnlyIfOverThreshold := False;  // always log, not just slow ones

With these few lines in the .dpr, the entire application is monitored without touching the controllers. The sample then shows advanced features where they truly add value — for example, structured extra data when a batch import partially fails:

// Each failed row is logged with structured context
LRowExtra := TJSONObject.Create;
LRowExtra.AddPair('row_number', TJSONNumber.Create(I + 1));
LRowExtra.AddPair('first_name', LFirstName);
LRowExtra.AddPair('last_name', LLastName);
LRowExtra.AddPair('error', LReason);
EW.Log(llWarning, Format('Import failed for row %d: %s %s (%s)',
  [I + 1, LFirstName, LLastName, LReason]), 'people', LRowExtra);

// The summary includes the complete array of failed rows
LExtra := TJSONObject.Create;
LExtra.AddPair('total_rows', TJSONNumber.Create(10));
LExtra.AddPair('imported', TJSONNumber.Create(LImported));
LExtra.AddPair('failed', TJSONNumber.Create(LFailed));
LExtra.AddPair('failed_rows', LFailedRows);  // TJSONArray with details
EW.Log(llWarning, 'Batch import: 7 imported, 3 failed', 'people', LExtra);

Opening the log in the ExeWatch dashboard, the extra data is visible in structured format — no longer a text message to interpret, but navigable data.

Public Repository with All Samples

We published a GitHub repository with integration examples for all SDKs and for different application types: github.com/danieleteti/ExeWatchSamples.

Every example includes a detailed README and can be compiled and launched in minutes. The API is deliberately uniform across SDKs, so switching between languages is seamless:

// Delphi
EW.Info('User logged in', 'auth');
EW.StartTiming('db.query', 'database');
EW.AddBreadcrumb('Search: "invoice 2024"', 'search');

// C# — same structure
EW.Info("User logged in", "auth");
EW.StartTiming("db.query", "database");
EW.AddBreadcrumb("Search: \"invoice 2024\"", "search");

// JavaScript — same structure
ew.info("User logged in", "auth");
ew.startTiming("db.query", "database");
ew.addBreadcrumb("Search: \"invoice 2024\"", "search");

On Premise

Several companies contacted us to ask whether it was possible to install ExeWatch in their own infrastructure. The reasons are predictable: corporate policies that prevent sending telemetry data to external services, sector-specific compliance requirements, latency needs or simply the preference for direct infrastructure control.

We added the On Premise option to the pricing page. It is not a self-service plan: it requires direct negotiation because each installation has different needs in terms of sizing, backup, updates and support. Those interested can write to us at exewatch@bittime.it.

Webinar and ITDevCon

On March 24th at 3:00 PM CET I will host a webinar dedicated to ExeWatch and Delphi VCL applications. After the first introductory video in English, this one will be in Italian and aimed at Delphi desktop developers. We will walk through the integration step by step, the advanced features and how to get the most out of the dashboard. English and Spanish webinars will follow shortly.

Register here: ExeWatch Webinar Registration

At the upcoming ITDevCon 2026 Spring Edition (in Italian) I will give a talk on ExeWatch where I’ll dive deep into integrations and advanced features — the kind you won’t want to do without once you’ve discovered them.

What’s Next

Work continues on two fronts. On the backend we are improving anomaly detection to make it more granular. On the SDK side, the next candidate is Python — many desktop applications use PyQt or Tkinter and have the same monitoring needs.

If you already use ExeWatch, all 1.8 features are already available in your account. If you haven’t tried it yet, the Hobby plan is free and requires no credit card.

Links and Resources

• Official website: exewatch.com
• Full changelog: exewatch.com/ui/changelog
• Integration examples: github.com/danieleteti/ExeWatchSamples
• March 24th Webinar: Register
• ITDevCon 2026 Spring Edition: itdevcon.it - The European Delphi conference
• Previous article: ExeWatch 1.6: Updates Tracking and Usage Analytics

ExeWatch — Monitoring for server, desktop and web applications. Built by bit Time Professionals.