Four Open-Source Developer Tools for Hyperping, Built by Develeap

Develeap, a DevOps consultancy, has been using Hyperping to manage monitoring across 57 tenants. That real production usage led them to build a set of open-source tools that extend Hyperping into the infrastructure-as-code, Python, and observability ecosystems.

The result is four interconnected projects, each driven by a concrete operational need.

Key takeaways

• Four open-source projects: Terraform provider, Python SDK, Prometheus exporter, and Go client
• All published on official registries: Terraform Registry, PyPI, Docker Hub
• The Go client is the shared foundation powering both the Terraform provider and the Prometheus exporter
• Built from real production needs managing 57 tenants, not as speculative tooling
• Full documentation available in the community section of the Hyperping docs

Terraform provider: monitoring as code

The Terraform provider is the most mature of the four projects. It lets you manage monitors, status pages, incidents, healthchecks, and maintenance windows as Terraform resources.

resource "hyperping_monitor" "api" {
  name                 = "API Health Check"
  url                  = "https://api.example.com/health"
  protocol             = "http"
  check_frequency      = 60
  expected_status_code = "200"
  regions              = ["london", "virginia", "singapore"]
}

Published on the Terraform Registry. Read the full announcement for setup details.

Python SDK: sync and async API client

The Python SDK gives you a clean client for the Hyperping API with both synchronous and asynchronous interfaces. All responses are Pydantic v2 models with full type hints.

from hyperping import HyperpingClient

client = HyperpingClient(api_key="sk_...")

monitors = client.list_monitors()
for m in monitors:
    print(f"{m.name}: {'down' if m.down else 'up'}")

For async workflows:

from hyperping import AsyncHyperpingClient

async def check_monitors():
    async with AsyncHyperpingClient(api_key="sk_...") as client:
        monitors = await client.list_monitors()
        return [m for m in monitors if m.down]

Install from PyPI with pip install hyperping. Documentation at /docs/community/python-sdk.

Prometheus exporter: Hyperping metrics in Grafana

The Prometheus exporter pulls monitoring data from the Hyperping API and exposes it as Prometheus metrics. This lets you visualize Hyperping uptime and response time data in Grafana alongside your other infrastructure metrics.

services:
  hyperping-exporter:
    image: khaledsalhabdeveleap/hyperping-exporter:latest
    ports:
      - "9116:9116"
    environment:
      HYPERPING_API_KEY: ${HYPERPING_API_KEY}

Add a scrape target in Prometheus and you are set. Available on Docker Hub. Documentation at /docs/community/prometheus-exporter.

Go client: the shared foundation

The Go client library (hyperping-go) is the core of this ecosystem. Both the Terraform provider and the Prometheus exporter are built on top of it, sharing the same API client with rate limiting, retries, and error handling.

If you are building custom Go tooling that integrates with Hyperping, this is the library to use. Documentation at /docs/community/go-client.

How the pieces fit together

hyperping-go (Go client)
  ├── terraform-provider-hyperping
  └── hyperping-exporter (Prometheus)

hyperping-python (standalone Python client)

The Go client handles the API communication layer. The Terraform provider adds Terraform resource abstractions on top. The Prometheus exporter adds metric collection and exposition. The Python SDK is independent, targeting a different language ecosystem.

This architecture means that when Develeap fixes a bug or adds API coverage in the Go client, both the Terraform provider and the Prometheus exporter benefit.

Getting started

All four projects are open-source and accept contributions on GitHub. If you run into issues or want to request features, open an issue on the relevant repository.