🚀 RustPulse — Secure, Real-Time Telemetry Engine

A Rust-native system for local, secure, and high-performance telemetry monitoring — built with Hexagonal Architecture, DDD, and TDD.

⚠️ Notice
This repository is a personal development project and is currently incomplete and not intended for public reuse, redistribution, or demonstration.
Please do not fork, copy, or republish any part of this code.
The project is not in a stable state, and does not reflect a usable or launch-ready application.
Thank you for respecting the intent of this work.

📖 Full Case Study

🔍 Read the full technical case study here or browse the weekly changelog.

📡 Overview

RustPulse is a modular, production-ready telemetry monitoring system written entirely in Rust. It is built for high-reliability environments such as simulation clusters, internal infrastructure, and latency-sensitive operations.

• ✅ Hexagonal Architecture (Ports & Adapters)
• ✅ Domain-Driven Design + Test-Driven Development
• ✅ Fast REST/gRPC APIs with PostgreSQL persistence
• ✅ CLI to Dashboard workflow with Prometheus/Grafana
• ✅ Offline-first design for edge/mission-critical ops
• ✅ Pluggable source architecture (trait-based)
• ✅ Currently uses MockTelemetrySource for simulation
• ✅ Real collectors can be added without touching core logic

🧱 Architecture Overview

• Hexagonal Architecture

  • Modular structure separating core logic and external interfaces

• Domain-Driven Design (DDD)

  • Node: agent identity and lifecycle
  • NodeTelemetry: real-time metrics from nodes
  • TelemetrySource: ingestion and validation layer

• Test-Driven Development (TDD)

  • Integration-driven workflows for async flows & interfaces

• Security & Auth

  • JWT for all API layers
  • Role-based access (planned)

⚙️ Tech Stack

Component	Tooling	Purpose
Backend Framework	Axum (Rust)	Fast and ergonomic async API building
Storage	PostgreSQL + SQLx / JSONL	Persistent or append-only telemetry logging
Transport	Tonic (gRPC)	Binary protocol for scalable services
CQRS	Axum + Async Executors	Clean separation of command/query
CLI Tool	Clap + Rust	Native CLI with full telemetry control
Auth	JWT (jsonwebtoken)	Secure session management
Observability	Prometheus + Grafana	Metrics & dashboards
Logging	Tracing	High-performance structured logs
CI/CD	GitHub Actions + Clippy	Linting, testing, quality gates

🔧 Features

• RESTful endpoints using axum
• Modular config via .env with dotenvy
• Centralized logging with tracing and tracing-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 anyhow crate.
• Testing: Mock data and unit test integration for validation.

📁 Project Structure

src/
├── adapters/                 # Outbound adapters (DBs, mocks, sources)
│   ├── mock_repo.rs
│   ├── postgres_metrics_repo.rs
│   └── telemetry_source_repo.rs
│
├── app/                      # Application services and orchestration
│   ├── errors.rs
│   └── metrics_service.rs
│
├── cli/                      # Command-line interface logic
│   ├── args.rs
│   └── commands.rs
│
├── core/                     # Domain logic: entities, ports, use cases
│   ├── domains/
│   │   ├── node.rs
│   │   └── telemetry.rs
│   ├── domains.rs            # Central re-exports (flat module style)
│   └── port.rs               # Domain ports (interfaces for adapters)
│
├── handlers/                 # Inbound interfaces: HTTP handlers (Axum)
│   ├── health.rs
│   ├── metrics.rs
│   └── root.rs
│
├── infra/                    # Infrastructure layer: DB, logging, startup
│   ├── db.rs
│   ├── logging.rs
│   └── startup.rs
│
├── tests/                    # Integration tests
│   ├── api.rs
│   └── common.rs
│
├── lib.rs                    # Library entry point (used for tests or crates)
└── main.rs                   # Binary entry point

🚀 How to Run

🚧 Coming soon

📸 Demo & Screenshots

🚧 Coming soon

🤝 Contributing

🚧 Project in early development. No contributions accepted yet. 🚧

📚 Documentation

🚧 Processing

Hosted docs will be available on docs.rs after first crate release.

📄 License

MIT OR Apache-2.0

Thanks for checking out RustPulse! Follow the full case study for deep dives into architecture, design, and async telemetry in Rust.