🔧 CLI to Dashboard. 📊 Metrics from metal to mission.
✨ Overview
RustPulse is a telemetry engine built in Rust for:
- Real-time, low-latency monitoring of distributed nodes
- Secure, offline-first architecture ideal for aerospace and defense
- Self-hosted metrics from CLI to dashboards
- Built with Axum, gRPC (Tonic), and Prometheus
✅ Why it Matters – Built for Mission-Critical Systems
Most observability stacks are cloud-first, slow, and bloated. RustPulse flips that:
⚙️ Telemetry close to the metal — fast, local, and built for edge systems.
The Problem:
- Cloud tools = high latency, vendor lock-in, unsuitable for edge
- No fine-grained control or Rust-grade safety/performance
The Solution:
- Rust-native, offline-first telemetry engine
- Optimized for aerospace, defense, and industrial ops
- Runs in disconnected environments (e.g. drones, satellites)
- Supports regulatory compliance with full local control
🛠️ Dev Timeline
RustPulse is not just code — it's a structured case study in Rust, architecture patterns, and async telemetry design.Designed for reviewers, contributors, and employers to follow technical decisions from day one.
📊 View Weekly Changelog:
🧱 Architecture Overview
- Hexagonal Architecture
Designed for modularity and clear boundaries between core logic and external interfaces.
- Domain-Driven Design (DDD)
Node: distributed agent identity and node status lifecycleNodeTelemetry: real-time metrics captured from individual nodesTelemetrySource: origin stream for telemetry ingestion, processing, and validation- Test-Driven Development (TDD)
Key domains:
Integration tests drive the implementation of each module, ensuring consistency across async flows and interface boundaries.
- Security & Auth
- JWT-based auth for all API layers
- Role-based access planned for CLI/API separation
⚙️ Tech Breakdown
Component | Tooling | Why it matters |
API | Axum (Rust) | Fast, async, minimal, and ergonomic for building APIs. |
Storage | PostgreSQL (SQLx), JSONL | Choice of persistent or append-only telemetry logging, depending on mission profile. |
Transport | Tonic (gRPC) | Efficient binary protocol for scalable microservices. |
CQRS | Axum + Async Executors | Implements separation of read and write operations for scalability and maintainability. |
CLI Tool | Clap + Rust | Powerful command-line interface with native Rust performance. |
DB | PostgreSQL + SQLx | Async, lightweight, and type-safe query execution. |
Auth | JWT (jsonwebtoken) | Secure, stateless session management. |
Observability | Prometheus + Grafana | Monitoring and visualizing application metrics. |
Logging | Tracing | High-performance structured logging for observability. |
CI/CD | GitHub Actions + Clippy | Ensures code quality through automated linting and testing pipelines. |
🛠 Feature Overview
- RESTful endpoints using
axum - Modular config via
.envwithdotenvy - Centralized logging with
tracingandtracing-subscriber - Integration & unit tests using
reqwest+tokio - Architecture: Hexagonal Architecture for scalable and maintainable design.
- Adapters: JSONL repository for efficient data persistence and querying.
- Asynchronous: Thread-safe operations with
tokio::sync::Mutex. - Error Handling: Simplified errors with
anyhowcrate. - Testing: Mock data and unit test integration for validation.
🚀 Planned Enhancements
- Prometheus integration for exporting metrics
- Structured alerting system with configurable thresholds
- Support for persistence via PostgreSQL database (SQLx-ready)
- Scalable, testable startup with middleware for request tracing
- Custom telemetry versioning to support schema evolution
More projects
/w=3840,quality=90,fit=scale-down)