Sentry Relay
https://github.com/getsentry/relay- Category
- Developer Tools
- Rank
- No. 383Tools index
- Pricing
- Open Source
- Type
- TOOL
- Builder
- getsentry
- GitHub
- 394 stars
- Latest release
- 26.8.0
- Date
About
Sentry's event forwarding and ingestion service for scrubbing PII and proxying events.
What it does
Relay moves selected responsibilities from Sentry SDKs and servers into a separate service. Its default mode passes traffic to a configured Sentry upstream. An optional processing mode instead normalizes, filters, and rate-limits events before producing them to Kafka.
Why it's ranked here
Relay has a focused architecture with authenticated service-to-service traffic and distinct forwarding and processing modes. It suits serious Sentry infrastructure, but processing introduces Kafka, Redis, native build tools, and local Sentry environment requirements that make it heavier than a simple intermediary.
What's good
Processing mode combines full event normalization, filtering, rate limiting, and Kafka output. Relay traffic supports signed authentication with timestamps, including rejection of expired signatures. The project also tests Rust units, integrations, the Python package, and protocol snapshots.
Tradeoffs
The default build excludes processing capabilities. Enabling them requires a C compiler and CMake, while integration testing also needs Redis and Kafka in their default configurations. Some setups require a local Sentry instance, and development expects the latest stable Rust toolchain.
How to use it well
Use Relay when operating Sentry infrastructure that needs a dedicated forwarding tier or server-side event processing before Kafka. Run the default configuration for forwarding, and enable processing only when its normalization and controls justify the extra services. It does not replace the configured Sentry upstream or surrounding ingestion infrastructure.
Technical notes+
The repository is a multi-crate Rust workspace with optional processing and crash-handler features plus a Python package backed by a native C ABI. relay-auth/src/lib.rs implements Relay IDs, version compatibility, key parsing, JSON packing, timestamped signatures, regular and prehashed signing, and explicit signature-expiration errors. Authentication currently uses Ed25519 through ed25519_dalek, although the source warns that the signing mechanism is an implementation detail. Full-feature processing produces events to Kafka and applies normalization, filtering, and rate limiting; its development and integration setup also depends on Redis, Python, a C compiler, and CMake.
Observed
- License
- Functional Source License, matching Sentry's stated licensing model.
- Primary language
- Rust, organized as a workspace with multiple crates and features.
- Packaging
- Released as a Relay binary and as a Python package backed by a native library.
- Interfaces
- Long-running service with command-line configuration initialization and run commands, plus Rust and Python library surfaces.
- Optional features
- Processing mode and native crash reporting are compile-time features; processing is disabled by default.
- Test structure
- Includes Rust unit tests, Python package tests, integration tests, and snapshot tests.
- Processing dependencies
- Processing development requires a C compiler and CMake; integration tests require Redis and Kafka.
Read from relay-auth/src/lib.rs.
What it can do
Forward events to Sentry backend
Application events and error data → Events transmitted to Sentry servers
Scrub personally identifiable information
Raw event data containing PII → Sanitized event data with PII removed
Proxy events between applications and Sentry
Event requests from applications → Proxied requests to Sentry infrastructure
Ingest application events
Event payloads from monitored applications → Processed event data ready for forwarding
Filter and process event data
Raw application telemetry and error events → Filtered and processed event stream
Tags
Tech Stack
Media
Comments (0)
No comments yet
Editorially curated, with community endorsements as a secondary signal. Corrections welcome.