RustPulse is an async telemetry engine exploring how to build reliable data pipelines and well-structured systems in Rust.
Designed as a case study in systems design, observability, and production-oriented engineering practices.
📘 Case study → https://vinecksie.super.site/rustpulse
RustPulse ingests and processes telemetry from distributed nodes using a modular architecture that isolates domain logic from infrastructure concerns.
Focus areas:
• async processing with Axum + Tonic (gRPC) • PostgreSQL persistence with JSONL fallback • structured tracing and observability • clean hexagonal architecture • production-style CI validation
• REST + gRPC ingestion endpoints • PostgreSQL storage via SQLx with idempotent schema init • JSONL fallback for offline-first scenarios • structured logging with tracing • OpenTelemetry tracing with Jaeger (local) • CRC32 request validation for data integrity • configurable environment-based runtime behaviour • CI pipeline with clippy, tests, coverage, cargo-deny
RustPulse follows a hexagonal architecture separating:
domain logic • application services • infrastructure adapters
Core domains:
• Node identity lifecycle • telemetry ingestion pipeline • validation and transformation flow
Design principles:
DDD-inspired boundaries TDD-oriented workflow composable ports and adapters
Rust · Axum · Tonic (gRPC) · SQLx · PostgreSQL · JSONL Tracing · OpenTelemetry · Jaeger Docker · GitHub Actions · cargo-deny
• PostgreSQL wiring with environment-driven configuration • SQLx setup documentation and schema initialization • CRC32 validation for /telemetry endpoint • OpenTelemetry tracing with Jaeger spans • improved CI pipeline with cargo-deny • concurrency configuration in CI workflow
This repository is a personal development project. This project is an educational but production-grade architecture showcase for Rust backend systems. The goal is to showcase Rust architecture, testing, and systems design practices — not to provide a production-ready tool.
RustPulse uses the same production-like deployment model in staging and production:
- Linux VM + Docker containers
- Orchestrated with Docker Compose
- Managed by systemd
- Environment-specific behavior is controlled only via injected environment variables and server-side env files
RustPulse explores how to design maintainable Rust services with emphasis on:
• clear architecture boundaries • async and concurrent data pipelines • observability and runtime introspection • reliable persistence strategies • production-oriented engineering practices
It serves as a practical reference for system-oriented Rust development.
MIT OR Apache-2.0