HOMER 10

HOMER 10 is a carrier‑grade, headless observability engine that ingests VoIP and WebRTC traffic via the HEP/EEP encapsulation format. From a developer’s perspective, it acts as a real‑time pipeline that transforms raw packets, signaling, RTP/RTCP reports and custom telemetry into structured logs, metrics, and traces. The system exposes a single ingestion endpoint that accepts HEPv3 packets over UDP/TCP, decodes them into JSON, and forwards the data to a backend observability store. This design removes the need for custom packet parsers and lets teams leverage mature query engines such as Grafana, Loki, or OpenTelemetry for analysis.

Architecture

• Language & Runtime: The core capture daemon is written in Go, chosen for its low‑latency networking stack and efficient concurrency model. The ingestion service runs as a stateless HTTP/UDP listener that can be horizontally scaled behind a load balancer.
• Observability Backend: HOMER relies on the open‑source qryn time‑series engine, which implements a Prometheus‑compatible API and an ElasticSearch‑like search layer. qryn stores the decoded JSON in a compressed columnar format, enabling sub‑millisecond query latency even for millions of packets per second.
• Storage: No SQL databases are required; data lives entirely in qryn’s native store. For long‑term retention, users can shard or replicate the qryn cluster across multiple nodes or integrate with object storage via the qryn exporter.
• Plugins & Extensibility: The capture daemon ships with a plugin system that allows developers to write custom HEP encoders or decoders in Go or Python. Webhooks, Kafka producers, and HTTP callbacks can be configured per‑session to forward events to external systems.

Core Capabilities

• Protocol Coverage: Native support for SIP, SDP, RTP/RTCP, RTCP‑XR, RTP statistics, WebRTC events, and arbitrary text streams (Syslog, CDRs).
• Dynamic Mapping: A JSON schema engine maps incoming HEP fields to qryn indices on the fly, enabling correlation across internal traffic and external telemetry sources.
• Real‑time Correlation: The ingestion layer tags each packet with a session identifier, allowing downstream dashboards to drill down from an aggregate metric (e.g., average jitter) to the exact packet that caused a degradation.
• API Surface: Exposes a REST API for querying, as well as a GraphQL endpoint that lets developers build custom dashboards or integrate with CI/CD pipelines.

Deployment & Infrastructure

HOMER is fully container‑ready; the official Docker image exposes HEP_PORT and QRYN_ENDPOINT as configurable environment variables. For production, the recommended pattern is to run a stateless capture pod behind a Kubernetes Service, with qryn deployed as a stateful set that can be scaled by adding replicas. The stateless design allows elastic scaling during traffic spikes without re‑capturing or replaying data. Minimal system requirements are a modern Linux kernel (≥4.15) and 2 CPU cores per capture instance for high‑volume deployments.

Integration & Extensibility

Developers can hook HOMER into existing observability stacks using standard protocols:

• Grafana – visualizes metrics and logs directly from qryn.
• Prometheus – scrape endpoints expose per‑session counters and histograms.
• OpenTelemetry Collector – forward traces to Jaeger or Zipkin for end‑to‑end call tracing.
• Webhook – emit JSON payloads to Slack, PagerDuty, or custom microservices.
  The plugin API also allows writing custom HEP processors that enrich packets with external data (e.g., IP geolocation) before they reach qryn.

Use Cases

• Enterprise Voice Monitoring – capture all SIP and RTP traffic across a data center, correlate with call quality dashboards, and alert on dropped calls.
• VoIP Service Provider – ingest traffic from multiple carriers, aggregate QoS metrics per customer, and generate monthly CDR reports.
• WebRTC Debugging – capture RTCP‑XR and WebRTC events to diagnose latency or packet loss in real time, feeding the data into a custom debugging UI.
• Compliance & Auditing – store all signaling logs in qryn for forensic analysis, with retention policies that comply with regulatory requirements.

Advantages

HOMER 10 gives developers a single, high‑throughput ingestion point that eliminates the need for custom packet capture pipelines. Its Go implementation guarantees low overhead, while qryn’s columnar store provides fast analytics without the complexity of managing a traditional SQL database. The open‑source license and active community mean no vendor lock‑in, and the ability to extend the system with plugins or external APIs keeps it future‑proof. In environments where real‑time visibility into VoIP traffic is critical, HOMER offers the performance, flexibility, and observability depth that alternatives like SIPp or Wireshark cannot match.