Beyla
Beyla is an open-source eBPF-based auto-instrumentation tool designed to simplify application observability.
Publisher review
Beyla is an open-source eBPF-based auto-instrumentation tool designed to simplify application observability. It targets developers and SREs who need to quickly gain insights into HTTP and gRPC services without modifying application code. Originally created by Grafana Labs and announced in 2023, Beyla was donated to the OpenTelemetry project in May 2025, becoming OpenTelemetry eBPF Instrumentation (OBI). Grafana Labs continues to maintain Beyla as its distribution of the upstream project, integrating it with the Grafana LGTM stack (Loki, Grafana, Tempo, Mimir) for full-stack observability.
Beyla uses eBPF to attach programs to Linux kernel points, capturing RED metrics (Rate-Error-Duration) and basic trace spans for services written in Go, C/C++, Rust, Python, Ruby, Java (including GraalVM Native), Node.js, .NET, and more. It requires a Linux kernel version 5.8 or higher and can be deployed in any Linux environment. Telemetry data is exposed in OpenTelemetry format and as native Prometheus metrics, enabling integration with Grafana dashboards and correlation with backend and infrastructure data. The tool can be configured to collect data from specific ports or executable paths, and supports Kubernetes metadata for filtering.
Beyla competes with other auto-instrumentation tools like OpenTelemetry language SDKs, Datadog's auto-instrumentation, and New Relic's zero-config agents. Its key differentiator is the use of eBPF, which eliminates the need for language-specific agents or code changes, reducing deployment complexity. However, it is limited to Linux environments and requires administrative privileges, which may not suit all workflows. Beyla's donation to OpenTelemetry positions it as a community-driven standard for eBPF-based instrumentation, but its reliance on eBPF means it cannot match the depth of manual instrumentation for complex business logic.
Honest trade-offs include the requirement for kernel 5.8+, which excludes older enterprise Linux distributions, and the need for root-like capabilities (BPF, SYS_PTRACE, NET_RAW, etc.) that may conflict with security policies. Beyla's eBPF approach captures HTTP/gRPC traffic at the kernel level, but it cannot instrument internal function calls or custom metrics without additional manual instrumentation. The project is relatively new (2023) and may have fewer community resources compared to mature solutions like OpenTelemetry SDKs. Additionally, while Beyla integrates well with Grafana, users of other observability stacks may need to adapt their pipelines.
How it works
-
eBPF-based auto-instrumentation
Uses eBPF to attach programs to Linux kernel points, capturing RED metrics and traces without modifying application code or configuration.
-
Multi-language support
Supports Go, C/C++, Rust, Python, Ruby, Java (including GraalVM Native), Node.js, .NET, and more for HTTP and gRPC services.
-
OpenTelemetry and Prometheus export
Exposes telemetry data in OpenTelemetry format and as native Prometheus metrics, enabling integration with various observability backends.
-
Kubernetes metadata support
Can filter and enrich telemetry data using Kubernetes metadata, such as pod labels and namespaces, for better context in distributed environments.
-
Grafana LGTM stack integration
Works seamlessly with Grafana, Loki, Tempo, and Mimir for visualization, correlation with logs and traces, and full-stack observability.
-
No code changes required
Instruments applications with a single command, eliminating the need for manual instrumentation or redeployment with language agents.
-
Linux kernel 5.8+ requirement
Requires Linux kernel version 5.8 or higher, limiting use on older enterprise distributions but leveraging modern eBPF capabilities.
Strengths and trade-offs
Strengths
- Eliminates the need for manual instrumentation or language agents, reducing deployment complexity and time to observability.
- Captures RED metrics and trace spans for HTTP and gRPC services across multiple languages (Go, C/C++, Rust, Python, Ruby, Java, Node.js, .NET) without code changes.
- Integrates natively with Grafana's LGTM stack (Loki, Grafana, Tempo, Mimir) for full-stack observability and correlation with backend and infrastructure data.
- Donated to OpenTelemetry as OpenTelemetry eBPF Instrumentation, ensuring community-driven development and interoperability with the broader OpenTelemetry ecosystem.
Trade-offs
- Requires Linux kernel version 5.8 or higher, excluding older enterprise distributions like RHEL 7 or Ubuntu 18.04.
- Needs administrative privileges or specific Linux capabilities (BPF, SYS_PTRACE, NET_RAW, etc.), which may conflict with security policies in hardened environments.
- Cannot instrument internal function calls or custom business logic metrics, limiting depth compared to manual instrumentation with OpenTelemetry SDKs.
- Relatively new project (2023) with a smaller community and fewer third-party integrations compared to mature solutions like Datadog or New Relic auto-instrumentation.
Pricing context
Open source (Apache 2.0 license). No paid tiers; Grafana Labs offers commercial support through Grafana Cloud subscriptions.
Getting started with Beyla
-
Install Beyla on Linux
Download the latest Beyla binary from the Grafana Labs GitHub releases page or build from source. Ensure your Linux kernel is version 5.8 or higher and that you have root or CAP_BPF privileges.
-
Run Beyla with a service
Start Beyla by specifying the executable path or port of your HTTP or gRPC service. Use the command `beyla --executable=/path/to/your/app` or `beyla --port=8080` to begin capturing RED metrics and traces without code changes.
-
Configure OpenTelemetry export
Set the `OTEL_EXPORTER_OTLP_ENDPOINT` environment variable to your OpenTelemetry collector or backend URL. Beyla will automatically export telemetry data in OpenTelemetry format for integration with Grafana or other observability platforms.
-
View metrics in Grafana
Open your Grafana instance and add a Prometheus or Tempo data source pointing to Beyla's metrics endpoint (default port 8999). Create a dashboard to visualize RED metrics and trace spans from your instrumented services.
-
Deploy Beyla in Kubernetes
Apply the Beyla DaemonSet manifest from the official repository to your cluster. Configure the `BEYLA_KUBE_METADATA_ENABLE=true` environment variable to enrich telemetry with pod labels and namespaces for better context.
Frequently Asked Questions
What is Beyla and how does it work for observability?
Beyla is an open-source eBPF-based auto-instrumentation tool that captures RED metrics and trace spans for HTTP and gRPC services without code changes. It attaches eBPF programs to Linux kernel points, requiring kernel 5.8 or higher, and exports data in OpenTelemetry format.
Which programming languages does Beyla support?
Beyla supports Go, C/C++, Rust, Python, Ruby, Java including GraalVM Native, Node.js, .NET, and more for HTTP and gRPC services. It uses eBPF to capture traffic at the kernel level, so no language-specific agents are needed for these supported runtimes.
Does Beyla require code changes to instrument my application?
No, Beyla requires no code changes or redeployment with language agents. It instruments applications with a single command using eBPF, which attaches to kernel points to capture telemetry data. This eliminates the need for manual instrumentation or modifying application configuration.
What are the Linux kernel requirements for running Beyla?
Beyla requires a Linux kernel version 5.8 or higher to leverage modern eBPF capabilities. This requirement excludes older enterprise distributions like RHEL 7 or Ubuntu 18.04. Additionally, it needs administrative privileges or specific capabilities such as BPF, SYS_PTRACE, and NET_RAW.
How does Beyla integrate with Grafana and OpenTelemetry?
Beyla exposes telemetry data in OpenTelemetry format and as native Prometheus metrics, enabling integration with Grafana dashboards and the LGTM stack (Loki, Grafana, Tempo, Mimir). It was donated to OpenTelemetry in May 2025, becoming OpenTelemetry eBPF Instrumentation for community-driven development.
What are the main trade-offs of using Beyla compared to other tools?
Beyla cannot instrument internal function calls or custom business logic metrics, limiting depth versus manual OpenTelemetry SDKs. It requires kernel 5.8+ and root-like capabilities, which may conflict with security policies. As a newer project from 2023, it has fewer community resources than mature solutions like Datadog.
Alternatives
How Beyla compares
Direct head-to-head against 2 competitors. Picked by 7wData.
Beyla
- Pricing
- Open source (Apache 2.0 license). No paid tiers; Grafana Labs offers commercial support through Grafana Cloud subscriptions.
- Target
- Beyla is an open-source eBPF-based auto-instrumentation tool designed to simplify application observability.
- Strength
- Eliminates the need for manual instrumentation or language agents, reducing deployment complexity and time to observability.
- Watch for
- Requires Linux kernel version 5.8 or higher, excluding older enterprise distributions like RHEL 7 or Ubuntu 18.04.
OpenTelemetry Collector
- Pricing
- Free, open-source; no licensing fees.
- Target
- Teams needing vendor-neutral telemetry collection and processing.
- Deployment
- Self-hosted or cloud.
- Strength
- Vendor-neutral standard with broad protocol support.
- Watch for
- Complex configuration and pipeline tuning required.
Datadog
- Pricing
- From $15/host/month for infrastructure monitoring.
- Target
- Enterprises seeking full-stack observability in a single platform.
- Deployment
- SaaS.
- Strength
- Unified dashboards and APM across 600+ integrations.
- Watch for
- Pricing escalates with host count and custom metrics.
User reviews
No user reviews yet. Be the first to write one.
Sources
Reporting on this tool draws on these publicly available sources.