Telemetry
What anonymous usage telemetry an Arc Enterprise node reports, what is deliberately excluded, and how to disable it in arc.toml or by environment variable across a cluster.
Arc sends anonymous usage telemetry to help improve the project. This page explains what data is collected, how it's used, and how to opt out.
Overview
Arc collects minimal, anonymous usage statistics to help the development team understand:
- How Arc is being deployed (operating systems, hardware configurations)
- Which Arc versions are in active use
- Basic system characteristics for optimization and testing
Privacy First
Arc does not collect user data, database contents, queries, or performance metrics. The only network information retained is a truncated subnet (never a full IP address), described below.
What is collected
Arc sends the following anonymous data every 24 hours (the subnet field is
the one exception: it is derived by the receiving server, not sent by Arc):
Instance information
-
instance_id: A random UUID generated on first run
- Stored in
./data/.instance_id - Unique per Arc installation
- Not linked to any personal information
- Stored in
-
timestamp: When the telemetry report was generated (UTC)
-
arc_version: The running version number (e.g.,
0.1.0) -
subnet: The network prefix of the address the report arrived from, with the host portion removed — IPv4 is truncated to a /24 (
203.0.113.47is recorded as203.0.113.0) and IPv6 to a /48. This is derived by the telemetry server from the connection itself; Arc does not send it and does not know its own public address. The full address is never stored and never written to a log — only the truncated prefix is retained. It is used to understand which regions Arc is deployed in; a /24 covers up to 254 hosts and does not identify an individual machine. Recorded asunknownwhen the address is unavailable.
System information
-
os: Operating system details
- Name (e.g., "Linux", "macOS", "Windows")
- Version (e.g., "Ubuntu 22.04", "macOS 14.0")
- Architecture (e.g., "x86_64", "arm64")
- Platform (e.g., "linux", "darwin")
-
cpu: CPU characteristics
- Physical cores (currently the same value as logical cores)
- Logical cores (threads)
- Frequency in MHz (currently always
null) - Usable cores: what a CPU quota (Kubernetes
limits.cpu,docker --cpus) leaves the process, read at startup. Equal to the logical cores without a quota (Arc 27.01.1 and later)
-
memory: System memory, in GiB
- Total: the machine's memory (
/proc/meminfoon Linux,hw.memsizeon macOS). Inside a container this is the host's memory, unless lxcfs is mounted over/proc/meminfo, in which case it equals the container limit. Releases before 27.01.1 sent the Arc process's own memory footprint here instead - Usable (Arc 27.01.1 and later): what a cgroup memory limit leaves the process, the lower of
memory.maxandmemory.high; the machine's memory when there is no limit. Read at startup
A value Arc cannot read is sent as
null. - Total: the machine's memory (
CLI installations (Arc releases after 26.09.1)
- clients.arcli: the arcli installations that talked to this node since its previous report (what the CLI sends and how to opt out: arcli privacy)
- arcli sends a random per-installation UUID (
Arcli-Installation-Idheader) and its version (User-Agent); the node keeps at most 256 distinct ids per report and marks the listtruncatedbeyond that - Only requests the node authenticated are counted (public routes such as
/healthnever are; with authentication disabled every served request is trusted); the id is never logged and nothing about the request (database, query, token) is recorded - The same id reaches every Arc server that installation uses, so Basekick can count how many CLI installations talk to how many instances
- Users disable it on the CLI side with
DO_NOT_TRACK=1orsend_installation_id = falsein~/.arcli/config.toml; disabling Arc telemetry on the node also stops it - Omitted entirely when no CLI installation was seen
- arcli sends a random per-installation UUID (
Example payload
{
"instance_id": "550e8400-e29b-41d4-a716-446655440000",
"timestamp": "2024-01-20T10:30:00Z",
"arc_version": "0.1.0",
"os": {
"name": "Linux",
"version": "Ubuntu 22.04",
"architecture": "x86_64",
"platform": "linux"
},
"cpu": {
"physical_cores": 16,
"logical_cores": 16,
"frequency_mhz": null,
"usable_cores": 4
},
"memory": {
"total_gb": 62.79518508911133,
"usable_gb": 8
},
"clients": {
"arcli": {
"installations": 1,
"truncated": false,
"list": [
{ "id": "0f0f0f0f-0f0f-4f0f-8f0f-0f0f0f0f0f0f", "version": "26.09.1", "last_seen": "2024-01-20T09:58:12Z" }
]
}
}
}What is NOT collected
Arc explicitly avoids collecting:
- User Data: No usernames, emails, or personal information
- Database Contents: No table names, schemas, or data
- Query Information: No SQL queries or query patterns
- Network Information: No full IP addresses or hostnames — only the truncated subnet described under What is collected
- Credentials: No API keys, passwords, or tokens
- File Paths: No directory structures or file names
- Performance Metrics: No query times, throughput, or resource usage
- Custom Configuration: No application-specific settings
How it works
Telemetry schedule
- First Transmission: right after Arc starts
- Subsequent Transmissions: Every 24 hours (
telemetry.interval_seconds) - Shutdown: one final report if CLI installations were seen since the last one (best effort, 5 s timeout), so nodes restarted more often than the interval still report them
- Primary Worker Only: Only the primary worker process sends telemetry (multi-worker deployments send one report)
Endpoint
Telemetry is sent to: telemetry.basekick.net
Network behavior
- If the telemetry endpoint is unreachable, Arc logs a warning but continues operating normally
- Failed transmissions are retried during the next scheduled transmission
- No telemetry data is queued or persisted locally
Startup logging
Arc logs telemetry status on startup. With the default console log format, the lines look like this (timestamps and source locations shortened):
When enabled:
INF > Telemetry enabled instance_id=<instance-id> interval=86400000interval is in milliseconds; 86400000 is 24 hours.
When disabled:
INF > Telemetry is DISABLED (opt-out via ARC_TELEMETRY_ENABLED=false)Arc prints the same line whether telemetry was turned off in arc.toml or with ARC_TELEMETRY_ENABLED=false.
Disabling telemetry
You can opt out of telemetry in two ways:
Option 1: configuration file
Edit your arc.toml file and add:
[telemetry]
enabled = falseFull Example:
[server]
host = "0.0.0.0"
port = 8000
[telemetry]
enabled = falseOption 2: environment variable
Set the environment variable before starting Arc:
export ARC_TELEMETRY_ENABLED=falseWith Docker:
docker run -e ARC_TELEMETRY_ENABLED=false ghcr.io/basekick-labs/arc:latestWith Docker Compose:
services:
arc:
image: ghcr.io/basekick-labs/arc:latest
environment:
- ARC_TELEMETRY_ENABLED=falseVerification
After configuring, restart Arc and check the startup log. For a package install:
sudo journalctl -u arc | grep -i "telemetry"For Docker, use docker logs arc 2>&1 | grep -i "telemetry". Telemetry is disabled when the latest startup shows this line and no Telemetry enabled line:
INF > Telemetry is DISABLED (opt-out via ARC_TELEMETRY_ENABLED=false)Why telemetry?
Benefits to the project
Anonymous telemetry helps the Arc team:
- Prioritize Platform Support: Understand which operating systems and architectures to focus on
- Test on Real Hardware: Know what CPU and memory configurations are common
- Track Version Adoption: See how quickly users upgrade to new releases
- Plan Deprecations: Identify when old versions are no longer in use
- Understand Reach: See which regions Arc is deployed in, at subnet granularity
Privacy considerations
Arc's telemetry is designed with privacy as a priority:
- Anonymous: Not linked to any individual. Addresses are truncated to a subnet before storage, so no report is tied to a specific machine
- Minimal: Only essential system characteristics
- Transparent: Full disclosure of what is collected
- Optional: Easy opt-out with no functionality loss
- No Tracking: No cookies, fingerprinting, or cross-site tracking
Frequently asked questions
Does telemetry affect performance?
No. Telemetry runs asynchronously and has negligible performance impact:
- Transmission occurs once per 24 hours
- Payload is ~500 bytes
- Network timeout is short (5 seconds)
- Failed transmissions don't block Arc operations
Can I verify what's being sent?
Yes. You can inspect the telemetry payload by:
- Network Inspection: Use tools like Wireshark or tcpdump to capture the request
- Source Code: Review the telemetry implementation in the Arc repository
- Logging: Enable debug logging to see telemetry payloads (future feature)
What happens to the data?
Telemetry data is:
- Stored securely on Basekick infrastructure
- Aggregated for statistical analysis
- Not shared with third parties
- Not used for commercial purposes
- Retained for a limited time (90 days)
Will Arc work if telemetry is blocked?
Yes. Arc functions identically whether telemetry is enabled or disabled. If the telemetry endpoint is unreachable (firewall, network issues), Arc logs a warning and continues normally.
Why not make it opt-in?
We believe in transparency and easy opt-out rather than opt-in because:
- Telemetry helps improve the product for everyone
- Data collected is truly anonymous and minimal
- Opt-out is simple and clearly documented
- Many users don't discover opt-in options
However, we respect your choice and make opting out straightforward.
Does Arc Enterprise have different telemetry?
No. Both Arc OSS and Arc Enterprise use identical telemetry collection. Arc Enterprise customers can request custom telemetry configurations for their deployments.
Privacy policy
For detailed information about how Basekick handles data, see our Privacy Policy (Coming Soon).
Support
If you have questions or concerns about telemetry:
Monitoring & Ops Playbook
Operational metrics for Arc Enterprise clusters: replication lag, tiering, governance, audit, per-role expectations, failover signals, and endpoints for inspecting or killing queries.
Automated scheduling
Configure paid scheduling for Arc continuous queries and retention policies, plus planned 27.01.1 edge-sync replication, with license checks, cluster eligibility, and monitoring.