What's New

Your usage figure counts the events you send, not the data stored

Monthly usage is the number of events ExeWatch has received and processed for you. Deleting data frees storage and leaves that number where it is, so the figure on screen is exactly the one your plan limit is checked against. Usage and Billing also open faster.

• Usage counts what you sent: your monthly figure is the number of events received and processed for your account, so it only ever moves when you send data. Deleting an application’s data or removing a customer frees storage and does not return allowance for the month — if you need more room before the period rolls over, that comes from a plan change, not from a delete
• All of your allowance is usable: batches are accepted right up to your monthly limit, so none of it is left on the table. A batch that straddles the limit is accepted whole, which means usage can finish the period slightly above your plan figure. That is a normal reading and not something you need to act on
• Usage and Billing open faster: the monthly figures are read from a running total rather than computed on the spot, so both pages open at the same speed however long an application’s history is
• An SDK you switch off stays off: turning logging off for an application holds until you turn it back on. The only pause that lifts on its own is a quota pause, once your usage is back under the limit
• The overview tells you why logging is off: the monthly-quota notice now appears only when we have paused logging for quota. Switch logging off yourself and the overview says so instead, so the banner always matches the real reason

Customer pages that open fast, however many devices

A customer with thousands of devices now opens as quickly as any other, and the device filters search all of them rather than only the page on screen.

• Customers: opening a customer is quick even when it has thousands of devices. The list pages through them, and the filters built from your custom device info now search every device, not only the ones on the page you are looking at
• A customer or a device is registered exactly once, however many readings arrive at the same instant — the database itself guarantees it, so identity stays stable under any burst of traffic
• API: GET /applications/{app_id}/customers/{customer_id}/devices is now paginated and returns 100 devices at a time. Use limit (up to 500) and offset to page through, and read X-Total-Count for the full number

Faster pages, and saved links that always open

Database tuning in our data centre, and saved or shared Logs links that keep their time range wherever you paste them.

• Database tuning in our data centre: pages that read a long history return sooner, and event collection keeps running smoothly while they do
• Logs: a saved or shared link carrying a time range or filters now always opens, even if the address was edited or shortened on the way

Long Usage periods stay out of everyone else's way

Computing the Usage tab over a long period no longer competes for the resources the rest of the service needs.

• Opening Usage on 90 days for an application with a large history no longer slows down event collection while the figures are computed, and the page itself is just as fast as before

Usage opens faster

The Usage tab now opens on the last 7 days and computes its figures considerably faster on applications with a large history.

• Usage: the page opens on the last 7 days, the same as Logs — the 30d and 90d periods are one click away in the selector
• Usage: charts, totals and comparisons with the previous period are computed with far less work, so the page appears sooner

Faster Logs and Usage pages

The Logs and Usage pages now open noticeably faster, especially on applications with a lot of history.

• Logs: the tag and version filters no longer slow the page down as your log history grows
• Logs: the page now opens on the last 7 days, which makes searching much faster — pick All Time from the time selector whenever you need the full history
• Usage: charts and figures load quickly, with the time they were computed shown next to the period selector and a button to recompute them

Export your data to CSV, and stay signed in longer

You can now export your data to CSV for your own reports and pivots, and choose to keep your session open so you are asked to sign in less often.

• Export to CSV: an Export button on the Logs, Timing and Metrics pages downloads exactly what you are viewing — filters included — ready to open in Excel
• Keep me signed in: tick the option on the login page to stay signed in for 7 days

Clearing an application's data now goes through support

The self-service “Reset Data” button has been removed from application settings. Clearing all logs and metrics for an application is permanent and cannot be undone, so it is now handled by our team on request.

• How to request one: contact support with the application name and we will schedule it
• Nothing else changes: deleting an application, API keys and alerts all work as before

Steadier ingestion as you approach your monthly limit

Applications close to their monthly event quota now keep sending at full speed. The usage check that runs near the limit no longer adds overhead to every batch.

• No slowdown near the limit: high-volume applications are unaffected as their usage approaches the plan ceiling
• Same accuracy: the quota is still enforced against your live usage figure

Your usage figure now matches your plan limit

The “Events This Month” number on the Billing page is now exactly the figure your plan limit is checked against, so an app can no longer be paused while the dashboard still shows plenty of room.

• Metric data points included: usage now shows logs and metric data points together, as the plan limit has always counted them
• No more spurious pauses: logging is paused only when your account is genuinely over its monthly quota
• Clearer breadcrumbs: the log detail now explains when an error carries no breadcrumb trail, and the docs cover the most common reasons

Reliability and maintenance improvements

Internal hardening and maintenance work to keep the platform running smoothly. No changes to the API, SDKs or user interface.

Zero data loss during traffic spikes

When every SDK retries at once (for example right after a server restart), the ingest API now answers “busy, retry later” instead of erroring out — your SDKs keep the data queued and deliver it on the next attempt.

• Graceful backpressure: ingest requests during a database-pool spike get 503 Retry-After, which all ExeWatch SDKs handle by retrying automatically
• Bigger burst headroom: the API absorbs sudden retry storms with a larger connection overflow, so spikes clear faster

Earlier heads-up before you hit your event quota

Account owners now get a second warning email at 90% of the monthly event quota, on top of the existing 80% warning and 100% notice — more time to upgrade before the SDK is paused.

• 90% quota warning: a new email alerts owners when usage crosses 90% of the monthly quota, sent at most once per billing month

Browser SDK: counters stay exact on unreliable connections

The JavaScript SDK keeps a counter’s pending value exact across upload retries, so a flaky network cannot change the number you read on the dashboard.

• Latest exewatch.v1.js: update to pick it up — hosted SDK users get it automatically

Hardened for the AI Era

As attackers increasingly weaponize AI, we’ve rolled out additional security systems across ExeWatch to keep your account and your data protected.

• Additional security systems: new safeguards across sign-in and the platform, working quietly in the background

Billing for Every Country & Easier Support

You can now enter a billing address from any country, EU VAT numbers keep working even when the EU checker is briefly unavailable, and getting in touch with support is a single click away.

• All countries selectable: the billing address country list now covers every country (EU members first, for VAT) instead of a short hard-coded set
• Resilient EU VAT checks: if the EU VIES service is slow or down, your address still saves and the VAT number is re-verified automatically at checkout and by a daily background check — the reverse charge applies as soon as it’s confirmed
• Support one click away: a Support link in the site menu and a Help & Support link inside the app both lead straight to the contact form

Smarter Gauge Sampling to Protect Your Quota

Apps that report gauge metrics very frequently from many devices can now have a minimum sampling interval applied, so a high-frequency gauge no longer burns through your monthly event quota. Counters are never affected — every increment is always kept.

• Quota-friendly gauges: when enabled for an app, gauge data points arriving faster than the configured interval are skipped server-side, keeping one representative value per interval per device
• Counters always intact: only gauges are rate-limited — counter totals are never reduced, so your sums stay exact

Faster Usage & Quota Calculations

Monthly usage and quota figures now load faster for accounts that send a lot of metrics, thanks to a new database index behind the scenes.

• Quicker monthly counts: computing how many events and metric data points you’ve used this month no longer scans unrelated data — usage and quota checks stay fast as your history grows

DLL SDK — Cleaner Startup & Clearer Stack-Trace Guidance

Using the ExeWatch DLL from a non-Delphi app (.NET, C++Builder, C++)? Startup is now quieter and the docs spell out exactly how error stack traces are captured.

• Quieter startup outside Delphi: the DLL raises the “missing VCL/FMX exception hook” notice only in hosts where that advice applies, so your event list stays about your application
• Clearer stack-trace guidance: the docs now explain that with the DLL your application supplies the error stack trace (with a ready-to-use C++Builder example), while automatic capture stays built in for the Delphi, .NET, Python and JavaScript SDKs

Nested Timing Traces — Profiler-Style Performance Trees

Timings can now be nested into a tree, just like a profiler. Wrap a piece of work in a trace and every timing inside it becomes a child span, shown as a waterfall in the dashboard — so you can see exactly where a slow operation spends its time, not just its total. Available in every SDK.

• Nested traces: StartTrace / EndTrace turn a group of timings into a parent/child tree. Open the trace from the log list to see a waterfall of every step and how long each took
• Loops collapse cleanly: a timing repeated in a loop (e.g. rendering 500 rows) merges into a single node with count, average, min, max and p95 — no wall of identical entries
• Every SDK: traces work in the Delphi native, .NET, Python, JavaScript and DLL SDKs, and ship with a ready-to-run demo in each sample project
• Smooth DLL upgrades: from this release, you can drop a newer ExeWatch DLL next to your existing application and it just works — no need to recompile your app to pick up new SDK features
• Fully backward compatible: existing single timings keep working exactly as before — tracing is opt-in and purely additive

Renewal Reminders for Custom Plans

On a custom plan arranged directly with our team? We'll now remind you by email before it ends, so renewing is never a last-minute surprise.

• Heads-up before expiry: a friendly email 7 days and 2 days before your custom plan's end date

Delphi SDK Reliability on Legacy Hardware

The Delphi SDK collects device info silently on machines with empty removable drives, and Linux cross-compilation is exercised on every build.

• Silent probe on removable drives: device-info collection skips floppy-reserved drive letters and suppresses the Windows error mode while it runs, so hosts with an empty removable drive (common on Server 2016) report without putting a dialog in front of your user
• Linux build verified continuously: the Delphi SDK's Linux64 cross-compile is now part of the standard build so the long-advertised Linux support can't silently regress
• Clarified platform floor: the SDK documentation now states the real Windows floor (Vista / Server 2008) and Delphi floor (XE8)

Timezone-Aware Lists, Binary Build History & Owner-Only Billing

Last-seen times now follow your timezone selector, device update history shows the exact binary build, you can jump straight to a customer from the Logs view, and billing actions are now restricted to account owners.

• Local times in lists: the "Last seen" column on the Customers and Devices pages now respects your timezone selector instead of always showing UTC
• Binary build in update history: the device update history now shows the binary build alongside the app version (e.g. 4.10 (4.1.0.1045)), so builds are distinguishable even when the app version is unchanged
• Jump to customer from Logs: click a customer's name in the Logs view to open their page
• Owner-only billing: opening the billing portal, starting a checkout, and editing the billing address are now restricted to account owners

Plan-Limit Notices & Request Hardening

Reaching your plan's metric limit now shows up directly in your logs, and oversized requests are turned away up front to keep the service fast and stable.

• Custom-metric limit notice: reaching your plan's metric limit now leaves an ew.system notice in your Logs view (cooldown 6h), in addition to the email
• Request size guard: abnormally large requests are rejected up front to protect platform stability

Data Anomaly Notices

ExeWatch now tells you, directly in your own logs, whenever it had to alter or drop something an SDK sent that wasn't quite right — so data issues never pass unnoticed.

• ew.system anomaly notices: a system message appears in your Logs view for an over-long truncated message, more than 8 global tags, use of the reserved ew.system tag, NULL/binary characters, oversized event metadata (capped at 16 KB), a device clock set in the future, or an extreme/garbage metric value

System Notices in Your Logs

When ExeWatch handles something automatically — like dropping a malformed metric — it now leaves a clear note directly in your app's log stream, so nothing happens silently behind your back.

• ew.system notices: the platform can post system messages into your Logs view (e.g. "dropped a malformed metric"), visible and filterable by the reserved ew.system tag
• Reserved tag: ew.system is reserved for ExeWatch and stripped from SDK-sent logs, so a system notice is always genuine
• Never counted against quota: these platform notices do not count toward your monthly event limit

Metrics Ingestion Hardening

Every valid metric in a batch is stored, whatever else the batch happens to contain.

• Resilient metric ingestion: a metric carrying a non-finite or out-of-range value is set aside and logged for you to find, while every other point in the same batch is saved normally

Quota Pause: Clearer & Self-Healing

When an account reaches its monthly event quota the SDK is paused to protect your plan. That state is now shown clearly in the dashboard and resumes on its own as soon as you are back under the limit.

• "Logging paused" banner: the app dashboard now shows a clear notice when logging is paused because the monthly event quota was reached — so you can tell at a glance why collection is paused
• Automatic resume: logging restarts on its own once usage drops back under your plan limit, instead of staying paused
• Shorter pause window: the maximum pause was reduced to one hour

Reset Data: Faster & Safer

Resetting application data is now near-instant and no longer touches your customer and device list — it clears historical logs and metrics only, and the customer/device roster repopulates automatically as your app keeps reporting.

• Logs & metrics only: Reset Data now deletes historical log events and metrics. Customers, devices, API keys, alerts and team settings are all preserved
• Your customer list stays put: active customers and devices are kept and simply keep updating as new data arrives, instead of disappearing and rebuilding
• More reliable on busy apps: the reset no longer competes with live data ingestion, so it completes quickly even on high-traffic applications

Ask for a new verification link from the login page

Signup confirmations, team invitations, alert notifications and welcome emails all travel the same monitored delivery path. If a verification link does not reach you, the login page issues a fresh one on demand.

• Verification link on demand: request a new confirmation email straight from the login page, without opening a support ticket
• Team invitations: invites reach new members as soon as you send them
• Alerts and welcome emails: same delivery path, same monitoring

Reset Data runs in the background, and tells you when it is done

Resetting application data runs asynchronously whatever the size of the dataset, with a completion email and clear feedback in the interface. Re-inviting a team member works straight away.

• Asynchronous Reset Data: the reset runs in the background in batches and completes whatever the size of the table, so an application with millions of log events clears as dependably as an empty one — and you can keep working while it runs
• "Reset queued" UI feedback: a banner appears in the app settings while the reset is in progress and the Reset button stays disabled until it completes, so you always know what state the app is in
• Reset completion email: account owners receive an email when the reset finishes, with a summary of how many log events, metrics and inactive customers were removed
• Re-invite a team member any time: inviting the same address again works straight away, whatever became of an earlier invitation — nothing to clean up first

C++Builder & MSVC SDKs, Global Tags & Per-Customer Alerts

Native C++Builder and Microsoft Visual C++ support join the SDK family via the ExeWatch DLL, alerts and logs can now be filtered by a specific customer and by global tags, and every SDK gains a graceful flush API plus thread-local timing measurements.

• C++Builder & MSVC support: ship to customers using Embarcadero C++Builder or Microsoft Visual C++ via the ExeWatch DLL. A dual-mode C header plus a ready-to-paste dynamic-loader file mean no static link is required, and older Delphi versions (4 to XE7) can now integrate too
• Global Tags: declare tags once in the Delphi or JavaScript SDK and they ride along on every log event; the log viewer gets a Global Tags filter so you can slice by deployment, tenant, build flavor, or anything else you want
• Per-customer alert filter: log-level and timing alerts can now be scoped to a single Customer ID, so high-volume customers no longer drown out the rest of your fleet
• WaitForSending API across all SDKs: console apps and short-lived processes can now block until queued logs are uploaded before exiting. Full traces are guaranteed even when an application exits quickly through Halt or after Application.Run returns
• Thread-local timings: every thread keeps its own independent timer stack across the Delphi, .NET and Python SDKs. Begin and end timing measurements with confidence in multi-threaded workloads
• JavaScript SDK error capture: HTTP errors now ship with the response body automatically, and a new httpErrorExtractor hook lets you customise exactly what gets attached
• Per-app file queue isolation: each application's API key gets its own offline-events subdirectory, so multiple ExeWatch apps can safely share a storage path on the same machine
• Monthly event quota notifications: account owners and team members get an email at 80% (warning) and at 100% (limit reached) of the monthly event quota, so a runaway logger never silently fills your plan

Several of these improvements began as conversations with teams running ExeWatch at enterprise scale. We refined them together and then made them available on every plan, so the wider community benefits from what those customers asked for. A heartfelt thank-you to everyone who took the time to share their use cases. Please keep them coming.

New Reorder Experience, Event Time & Full Anonymization

A dedicated dialog for reordering applications, log timestamps that reflect when the event actually happened on the client, in-app confirm dialogs and toasts in place of browser popups, and a Delphi SDK that keeps usernames on the machine when anonymization is enabled.

• Redesigned app reordering: a dedicated dialog with a clean list, a clear "Custom order active" indicator, and one-click Reset to default
• Event Time column in the log list: the log viewer now shows when the event actually happened on the client, not when it arrived at the server (the log detail modal still displays both plus the network latency)
• Sticky page header: the title bar stays visible while you scroll long log or timing tables
• In-app confirm dialogs and toasts: native browser popups are gone — delete app, reset data, reset order, sync billing, etc. now use the dark-themed ExeWatch dialogs and success toasts
• Delphi SDK anonymization covers the username: with AnonymizeDeviceId enabled, both the device ID and the Windows login stay on the machine — neither reaches tooltips or the Devices page
• Delphi SDK line endings: ExeWatchSDKv1.pas ships with CRLF, so RAD Studio takes it into a project without prompting about inconsistent line endings
• Delphi docs updates: corrected the InitialCustomDeviceInfo example and added a new "Coexisting with madExcept / EurekaLog" integration section
• Global SDK Configuration in Admin Console: set flush interval, batch size, sampling rate and max message length once and have the value applied to every application
• Confirm dialogs stay on top: confirmations always render above the App Settings modal, so the choice you are asked to make is the one in front of you

Python SDK, and anonymization under overflow checking

A new Python SDK with full feature parity, and Delphi’s AnonymizeDeviceId working in projects that compile with overflow checking on.

• Python SDK: single-file SDK for Python 3.7+ with zero external dependencies — logging, breadcrumbs, timing, metrics, user identity, tags, device info, offline persistence, background shipping
• Python SDK selectable when creating Windows, Linux, or macOS applications
• SDK download endpoint, integration guide, and inline code snippets for Python
• Public documentation and landing page updated with Python SDK section
• Delphi SDK AnonymizeUsername runs in projects that enable overflow checking ({$Q+})
• Delphi DLL SDK rebuilt for 32-bit and 64-bit with the same change
• New invoke sdk-python task integrated into invoke sdk-all

Android Support & UI Improvements

Full Android platform support for the Delphi SDK, clearer breadcrumbs, and the FMX GUI option on the SDK download page.

• Full Android platform support in Delphi SDK: device info (RAM, CPU, display resolution), app version from AndroidManifest, kernel thread ID
• FMX GUI option available on the SDK download page for Delphi apps
• Breadcrumb indicator icon in log list with count tooltip
• Sequential numbering on breadcrumbs in log detail view

Stack Traces, Generic Webhooks & UI Improvements

Automatic stack trace capture on all errors, generic webhook integration with retry, and a more compact log detail view.

• .NET / C# SDK with full Delphi parity: logging, breadcrumbs, timing, metrics, hardware info, exception capture, offline persistence
• Automatic stack trace capture for all Error and Fatal logs (Delphi SDK, Windows)
• Generic webhook integration with token authentication and automatic retry (Business plan)
• New Integrations modal for Discord and Webhook configuration with per-type test
• Exception details card in Log Detail (class, source, address)
• Compact Log Detail layout with message immediately visible
• Sortable Metrics tables with sort persistence across refresh
• Devices table with fixed-width columns and cleaner layout
• Breadcrumbs stay isolated per thread on Linux
• Optimized map file loading with O(n log n) sorting

Custom Metrics, Device Snapshots & Responsive UI

Send custom numeric metrics, plan-based health monitoring, immutable device state snapshots on log events, and a fully responsive interface.

• Custom Metrics page with counters and gauges, time-series charts, and gauge configuration
• Delete metric data directly from the detail modal
• Health monitoring tiered by plan: basic (Hobby), error-based (Pro), full (Business)
• Anti-flapping logic prevents rapid health status oscillations
• Share applications in read-only mode with external users — give clients and partners live visibility without granting full access
• Device state snapshots: each log event captures an immutable snapshot of the device state at creation time
• Version filters on Logs page to filter by App Version and Binary Version
• Adaptive toolbar with three responsive layouts for desktop, tablet, and mobile
• Optimized background jobs for better scalability
• JavaScript SDK: logs survive the browser tab closing

Health Alerts, Discord & Security Hardening

Automatic health status monitoring with notifications, Discord integration, and infrastructure security improvements.

• Health Score on the overview dashboard — monitors error rate, crashes, and slow operations (24h)
• Health status change alerts: automatic email & Discord notifications when an app degrades or recovers
• Health history modal with 7-day transition timeline
• Discord webhook integration for all alert types (log level, timing, health)
• Rate limiting per IP on login, SDK ingest, and API endpoints
• JavaScript SDK: ignoreUrls option to filter out third-party errors
• Privacy Policy & Terms of Service guide with GDPR-compliant templates
• Timing page: special characters in timing IDs display correctly, and durations read more clearly
• Smarter device table: long OS versions are now truncated, platform icons in sidebar

Usage Analytics

Understand how your software is used with comprehensive usage analytics.

• Active sessions, devices, and customers over time with trend deltas
• Usage heatmap (hour × day of week) to spot peak usage patterns
• Top customers ranking by session count
• OS distribution chart across all devices
• Error rate trend by app version
• Time range selector: 7d, 30d, 90d

Delphi 12 Support & OS Change Tracking

SDK compatibility improvements and enhanced device tracking.

• Delphi 12 (Embarcadero RAD Studio) full SDK support
• Automatic OS change detection on devices (e.g. Windows 10 → 11)
• App Updates page improvements with OS update badges

Thread-Local Breadcrumbs

Improved breadcrumb handling for multi-threaded applications.

• Thread-local breadcrumb storage in Delphi SDK
• Each thread maintains its own breadcrumb trail
• Alerts page timezone: dates now convert UTC → local timezone

Device Version History & Automatic Exception Capture

Track version updates across all devices and capture unhandled exceptions automatically.

• Device version history with timeline in device modal
• App Updates page with stats, filters, and pagination
• Automatic unhandled exception capture in Delphi SDK
• VCL hook unit for GUI exception capture
• FMX hook unit for FireMonkey exception capture
• Console app crash detection via System.ExceptProc

GDPR Compliance

Comprehensive GDPR compliance features for EU data protection requirements.

• Account pseudonymization instead of hard delete
• Complete data export including all personal data
• Data Processing Agreement (DPA) template
• Right to Restriction of Processing
• Email change functionality
• Email notifications for restriction and email changes

Email Alerts & Platform-Based Architecture

Threshold-based email alerts and per-platform application architecture.

• Email alerts with configurable thresholds, cooldown, and tag filters
• Timing alerts for slow operation detection
• One application = one platform (Windows, Linux, macOS, Android, Browser). iOS coming soon
• Platform-based API key prefixes (ew_win_, ew_lin_, ew_mac_, etc.)
• Configurable slow threshold per application
• Sortable columns on Timing page

Initial Release

The first public release of ExeWatch, a complete APM platform for server, desktop, and web applications.

• Centralized log aggregation with 5 severity levels
• Performance timing and profiling (Avg, Min, Max, P95)
• Hardware info collection (CPU, RAM, disks, monitors, OS)
• Multi-customer and multi-device tracking
• Breadcrumbs trail for debugging
• User identity tracking
• Global tags and version tracking
• Offline persistence with automatic retry
• Native Delphi SDK (VCL, FMX, Console, Services)
• JavaScript SDK for web applications
• Team management with role-based access
• Stripe billing integration (Hobby, Pro, Business plans)