How carverauto/serviceradar works
Project Type and Purpose
• ServiceRadar is a full-stack, distributed network and service monitoring system.
• It comprises edge components (Agents, Checkers, Pollers), a centralized Core service (API, rule engine, alerting, stream processing), and a Web UI.
• It uses Go for most backend microservices, Rust for high-performance rule engines and checkers, Next.js/TypeScript for the dashboard, NATS for messaging, gRPC/HTTP for RPC, and Timeplus Proton/ClickHouse for stream storage.
Main Components
a. Edge Components
• Agent (cmd/agent, pkg/agent)
• Poller (cmd/poller, cmd/poller-ng, pkg/poller)
• Specialized Checkers (cmd/checkers/{dusk, rperf-client/server, snmp, sysmon})
b. Messaging & Consumers
• NATS broker (packaging/nats, pkg/natsutil)
• Consumers (cmd/consumers/{db-event-writer, netflow, zen}, pkg/consumers)
• Log forwarder Flowgger (cmd/flowgger)
• OpenTelemetry collector (cmd/otel, pkg/logger, pkg/http, proto/opentelemetry)
c. Core Service
• API & Rule Engine (cmd/core, pkg/core)
• Database layer (pkg/db, migrations)
• Model definitions (pkg/models)
• SRQL parser & translator (pkg/srql)
• Metrics store (pkg/metricstore), metrics manager (pkg/metrics)
• Alerts & notifications (Discord, Webhooks)
d. Web UI
• Next.js app (web/src/app, web/src/components) served behind Nginx (packaging/web/nginx.conf)
• Communicates over HTTP to Core API
e. Packaging & Deployment
• Dockerfiles (cmd/*, docker/, packaging/*)
• Kubernetes manifests (k8s/demo)
• install-serviceradar.sh, Makefile, Goreleaser config
Component Interactions
• Agent exposes gRPC endpoints for local service status.
• Poller connects to Agents via mTLS-secured gRPC, invokes Checkers for SNMP, ICMP, Sysmon, RPerf, Dusk, then publishes results to NATS or directly to Core.
• Core subscribes to NATS topics or accepts gRPC calls from Pollers, processes events through the Rust-based rule engine, writes metrics/logs to Timeplus Proton (ClickHouse), and persists device/poller state in a relational DB.
• Consumers (db-event-writer, netflow, zen) subscribe to NATS topics, transform or enrich events, then write to Core’s database or external sinks.
• Flowgger ingests logs via file/UDP/TCP/Redis, encodes them (Cap’n Proto, GELF, etc.), and publishes to NATS or Core.
• OpenTelemetry agent collects traces/logs/metrics from microservices, forwards to Core or third-party backends.
• Web UI issues REST calls to Core’s HTTP API (behind Nginx). Authentication via API key or JWT.
Architectural Patterns & Principles
• Microservices: each major function (agent, poller, checker, core, consumer) is a separate service.
• Event-driven / Publish-Subscribe: NATS is the central message bus.
• Stream Processing: Timeplus Proton (Rust) for high-throughput OLAP, ClickHouse as storage.
• Layered Architecture: edge layer (polling, data collection), service layer (rule engine, API), data layer (stream store, relational DB).
• Polyglot: Go for orchestration and API, Rust for performance-critical components, TypeScript for UI.
• Security: mTLS between services, API key/JWT for UI, TLS for NATS.
Essential Architectural Elements to Capture
• Security boundary showing mTLS and API authentication.
• Message bus as central backbone for decoupling.
• Storage tier with both OLAP (Proton/ClickHouse) and OLTP (Core DB).
• UI layer with reverse proxy (Nginx) and API gateway.
• Extensible plugin/checker architecture: illustrate how a new checker module fits.
• Deployment descriptors (Docker/K8s) should appear as annotations.