Arc Output Plugin for Telegraf: Collect Metrics from 300+ Systems

If you've ever set up infrastructure monitoring, you've probably used Telegraf.

It's the Swiss Army knife of metric collection—a single binary that can pull data from over 300 different sources. CPU metrics from your servers. Query stats from your databases. Container metrics from Kubernetes. Sensor data from IoT devices. If it generates metrics, there's probably a Telegraf plugin for it.

Telegraf is one of my favorite pieces of software. At Basekick, we use it to monitor our own infrastructure and our customers' systems. It's reliable, lightweight, and just works. When you need to collect metrics from anywhere, Telegraf is the answer.

Today, Arc joins the Telegraf ecosystem with an official output plugin, available starting in Telegraf 1.33.

This means you can now collect metrics from any of Telegraf's 300+ input plugins and send them directly to Arc. System monitoring, database metrics, cloud service telemetry, industrial IoT—all flowing into Arc's high-performance time-series storage with a few lines of configuration.

Why Telegraf Matters

Before diving into the plugin, let me explain why Telegraf is such a big deal in the monitoring ecosystem.

Plugin-Driven Architecture

Telegraf's power comes from its plugin system. There are four types of plugins:

• Input plugins collect metrics from systems, services, and APIs
• Processor plugins transform and filter metrics in-flight
• Aggregator plugins compute statistics over time windows
• Output plugins send metrics to storage backends (like Arc)

With over 300 input plugins, you can collect data from virtually anything:

Lightweight and Battle-Tested

Telegraf is a single Go binary with no external dependencies. It runs on Linux, Windows, macOS, and ARM devices. It's been deployed in production by thousands of organizations, from startups to Fortune 500 companies.

InfluxData (the company behind Telegraf) built it to work with InfluxDB, but Telegraf supports dozens of output destinations. Now Arc is one of them.

The Arc Output Plugin

Here's what the Arc output plugin configuration looks like:

[[outputs.arc]]
  url = "https://arc.basekick.net/api/v1/write/msgpack"
  api_key = "$ARC_TOKEN"
  content_encoding = "gzip"
  database = "telegraf"

That's it. Four lines to connect Telegraf to Arc.

Configuration Options

The plugin uses Arc's MessagePack columnar format for efficient data transfer. With gzip compression enabled, you'll see significant bandwidth savings—especially useful when collecting high-cardinality metrics.

Full Working Example: System Metrics

Let's set up complete system monitoring. This configuration collects CPU, memory, disk, network, and system metrics from a server and sends them to Arc.

Create a file called telegraf.conf:

# Global agent configuration
[agent]
  interval = "10s"
  round_interval = true
  metric_batch_size = 1000
  metric_buffer_limit = 10000
  collection_jitter = "0s"
  flush_interval = "10s"
  flush_jitter = "0s"
  precision = "0s"
  hostname = ""
  omit_hostname = false
 
# Arc output plugin
[[outputs.arc]]
  url = "http://localhost:8000/api/v1/write/msgpack"
  api_key = "$ARC_TOKEN"
  content_encoding = "gzip"
  database = "telegraf"
 
# CPU metrics - usage per core and total
[[inputs.cpu]]
  percpu = true
  totalcpu = true
  collect_cpu_time = false
  report_active = false
  core_tags = false
 
# Memory metrics
[[inputs.mem]]
  # No configuration needed - collects all memory stats
 
# Disk metrics - space usage per mount point
[[inputs.disk]]
  ignore_fs = ["tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs"]
 
# Disk I/O metrics - read/write operations
[[inputs.diskio]]
  # No configuration needed
 
# Network metrics - bytes/packets per interface
[[inputs.net]]
  # No configuration needed
 
# System metrics - load average, uptime, users
[[inputs.system]]
  # No configuration needed
 
# Process metrics - count by state
[[inputs.processes]]
  # No configuration needed
 
# Swap metrics
[[inputs.swap]]
  # No configuration needed

This configuration:

• Collects metrics every 10 seconds
• Batches up to 1,000 metrics before flushing
• Compresses data with gzip
• Ignores virtual filesystems for disk metrics
• Tracks CPU usage per core and total

Running Telegraf

With Docker

# Set your Arc token
export ARC_TOKEN="your-arc-token-here"
 
# Run Telegraf with your config
docker run -d \
  --name telegraf \
  -e ARC_TOKEN=$ARC_TOKEN \
  -v $(pwd)/telegraf.conf:/etc/telegraf/telegraf.conf:ro \
  -v /:/hostfs:ro \
  -e HOST_ETC=/hostfs/etc \
  -e HOST_PROC=/hostfs/proc \
  -e HOST_SYS=/hostfs/sys \
  -e HOST_VAR=/hostfs/var \
  -e HOST_RUN=/hostfs/run \
  -e HOST_MOUNT_PREFIX=/hostfs \
  telegraf:1.37

The volume mounts give Telegraf access to host system metrics when running in a container.

With Systemd (Native Install)

If you've installed Telegraf natively:

# Install Telegraf 1.37+ (Debian/Ubuntu)
wget https://dl.influxdata.com/telegraf/releases/telegraf_1.37.0-1_amd64.deb
sudo dpkg -i telegraf_1.37.0-1_amd64.deb
 
# Copy your config
sudo cp telegraf.conf /etc/telegraf/telegraf.conf
 
# Set the API token in the environment
sudo systemctl edit telegraf
# Add: Environment="ARC_TOKEN=your-token-here"
 
# Start Telegraf
sudo systemctl enable telegraf
sudo systemctl start telegraf
 
# Check status
sudo systemctl status telegraf

Verifying Data in Arc

Once Telegraf is running, you should see metrics flowing into Arc.

Check Telegraf's logs to confirm data is being sent:

docker logs telegraf

Query Arc to verify the data arrived:

curl -X POST http://localhost:8000/api/v1/query \
  -H "Authorization: Bearer $ARC_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sql": "SHOW TABLES FROM telegraf"}'

You should see tables for each metric type: cpu, mem, disk, diskio, net, system, processes, swap.

Example Queries

Now let's query the collected metrics.

CPU Usage Over Time

SELECT
  time,
  host,
  cpu,
  usage_user,
  usage_system,
  usage_idle
FROM telegraf.cpu
WHERE time > NOW() - INTERVAL '1 hour'
  AND cpu = 'cpu-total'
ORDER BY time DESC
LIMIT 100;

Memory Utilization

SELECT
  time,
  host,
  used_percent,
  available,
  used,
  total
FROM telegraf.mem
WHERE time > NOW() - INTERVAL '1 hour'
ORDER BY time DESC
LIMIT 50;

Disk Space by Mount Point

SELECT
  time,
  host,
  path,
  used_percent,
  free,
  total
FROM telegraf.disk
WHERE time > NOW() - INTERVAL '1 hour'
ORDER BY time DESC;

Network Throughput

SELECT
  time,
  host,
  interface,
  bytes_sent,
  bytes_recv,
  packets_sent,
  packets_recv
FROM telegraf.net
WHERE time > NOW() - INTERVAL '1 hour'
ORDER BY time DESC;

System Load Average

SELECT
  time,
  host,
  load1,
  load5,
  load15,
  uptime
FROM telegraf.system
WHERE time > NOW() - INTERVAL '1 hour'
ORDER BY time DESC;

What You Can Monitor

System metrics are just the beginning. Here's a taste of what Telegraf can collect:

Databases

Monitor your database performance without custom instrumentation:

# PostgreSQL
[[inputs.postgresql]]
  address = "postgres://user:password@localhost/dbname"
 
# MySQL
[[inputs.mysql]]
  servers = ["user:password@tcp(localhost:3306)/"]
 
# MongoDB
[[inputs.mongodb]]
  servers = ["mongodb://localhost:27017"]
 
# Redis
[[inputs.redis]]
  servers = ["tcp://localhost:6379"]

Containers and Orchestration

# Docker containers
[[inputs.docker]]
  endpoint = "unix:///var/run/docker.sock"
 
# Kubernetes
[[inputs.kubernetes]]
  url = "http://localhost:10255"

Cloud Services

# AWS CloudWatch
[[inputs.cloudwatch]]
  region = "us-east-1"
  namespace = "AWS/EC2"
 
# Azure Monitor
[[inputs.azure_monitor]]
  subscription_id = "your-subscription-id"

Message Queues

# Kafka
[[inputs.kafka_consumer]]
  brokers = ["localhost:9092"]
  topics = ["telegraf"]
 
# RabbitMQ
[[inputs.rabbitmq]]
  url = "http://localhost:15672"

IoT and Industrial

# MQTT (IoT sensors)
[[inputs.mqtt_consumer]]
  servers = ["tcp://localhost:1883"]
  topics = ["sensors/#"]
 
# Modbus (Industrial equipment)
[[inputs.modbus]]
  name = "device"
  slave_id = 1
  timeout = "1s"

Every one of these plugins—and hundreds more—now works with Arc out of the box.

The Power of Portable Storage

Here's what makes the Telegraf + Arc combination special.

Telegraf collects your metrics. Arc stores them in Parquet files. Those Parquet files are readable by any tool—DuckDB, Spark, pandas, Snowflake.

Your infrastructure metrics aren't locked in a proprietary format. Want to analyze five years of CPU data in a Jupyter notebook? Load the Parquet files directly into pandas. Want to join your metrics with business data in your data warehouse? Query the same files from Snowflake.

Telegraf gives you collection flexibility. Arc gives you storage portability. Together, they give you a monitoring stack without vendor lock-in.

Conclusion

The Arc output plugin for Telegraf opens up a world of monitoring possibilities:

• 300+ input plugins for collecting metrics from any source
• Efficient transfer with MessagePack and gzip compression
• Portable storage in standard Parquet format
• SQL queries for instant metric analysis
• No lock-in—your data stays accessible

If you're already using Telegraf, switching to Arc is a config change. If you're building new monitoring infrastructure, Telegraf + Arc gives you collection breadth with storage flexibility.

Try it out. The plugin is available now.

Resources:

• https://github.com/basekick-labs/arc
• Arc Documentation
• Telegraf Plugin Directory
• https://github.com/influxdata/telegraf
• Discord Community

Questions? Reach out on Twitter or join our Discord.