AutoGineer
Generated banner for Beyla
Generated logo for Beyla

Beyla

Grafana LabsOfficialPublished by Grafana Labs

  • Skill
  • Tool integration
  • Cloud and DevOps
  • Apache-2.0
  • Low risk
Download ZIP

From the author

Auto-instrument an application's HTTP / gRPC / DB traffic with Grafana Beyla eBPF — no code changes, no SDK, no restart. Covers requirements (Linux 5.8+ with BTF, CAP_SYS_ADMIN, host PID), language matrix (Go / Java / Python / Ruby / Node / .NET / Rust / C++ / PHP), Docker + Helm + DaemonSet install, port- / process- / Kubernetes-metadata discovery, OTLP traces + Prometheus metrics export, routes decorator (cardinality control), trace sampling, and Grafana Cloud via Alloy. Use when adding observability to a service you can't recompile, instrumenting a closed-source binary, getting RED metrics + spans onto Tempo/Mimir without touching the app, or rolling Beyla as a cluster-wide DaemonSet — even when the user says "zero-code APM", "instrument legacy app", "trace this binary", "eBPF observability", or "no SDK" without naming Beyla.
— the description by Grafana Labs

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Grafana Beyla is an eBPF-based tool that provides zero-code observability for applications. It automatically captures HTTP, gRPC, and database traffic, emitting OTLP traces and Prometheus metrics. Because it operates at the kernel level, it requires no application restarts, recompilation, or SDK integration, making it ideal for legacy systems or closed-source binaries.

What it does

  • Auto-instruments applications using eBPF technology
  • Exports telemetry as OTLP traces and Prometheus metrics
  • Supports a wide range of languages including Go, Java, Python, and Node.js
  • Provides automatic service discovery via port, process name, or Kubernetes metadata
  • Includes a routes decorator for cardinality control and trace sampling
  • Integrates seamlessly with Grafana Cloud via Alloy

When to use it

  • When you need to add observability to a service that cannot be recompiled
  • When instrumenting closed-source binaries or legacy applications
  • When you need RED metrics and spans without modifying application code
  • When deploying cluster-wide observability via a Kubernetes DaemonSet

Advantages

  • Zero-code: no SDKs or code changes required
  • Non-intrusive: no application restarts needed
  • Language agnostic: supports diverse runtimes including .NET, Rust, and PHP
  • High visibility: captures HTTP, gRPC, and database query performance

Usage examples

“How do I instrument a running binary on port 8080 using Docker?”
Run the Beyla container with --privileged and --pid=host, setting BEYLA_OPEN_PORT to 8080 and pointing the OTLP endpoint to your collector.
“How can I deploy Beyla across my entire Kubernetes cluster?”
Use the provided DaemonSet configuration with the necessary RBAC permissions and hostPID enabled to allow eBPF probes to monitor pods.
“How do I control the cardinality of my HTTP metrics?”
Configure the routes decorator in the Beyla YAML to define patterns for path matching and set an unmatched strategy like heuristic to clean up metrics.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/grafana/beyla/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip beyla.zip -d .agents/skills

Documentation by Grafana Labs

Grafana Beyla

Docs: https://grafana.com/docs/beyla/latest/

Zero-code HTTP / gRPC / DB instrumentation via eBPF. Emits OTLP traces + Prometheus metrics.

Prerequisites

  • Linux kernel 5.8+ with BTF enabled (ls /sys/kernel/btf/vmlinux must exist)

  • Root or CAP_SYS_ADMIN (or privileged: true in Kubernetes + hostPID: true)

  • x86_64 or ARM64

  • An OTLP receiver (Tempo, Alloy, OTel Collector) reachable from Beyla

Common Workflows

1. Instrument a single binary with Docker
# 1. Run Beyla against the app's port (the app must already be running, listening on 8080)
docker run --privileged --pid=host \
  -v /sys/kernel/debug:/sys/kernel/debug:ro \
  -e BEYLA_OPEN_PORT=8080 \
  -e BEYLA_PROMETHEUS_PORT=8999 \
  -e OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4318 \
  -p 8999:8999 \
  grafana/beyla

# 2. Generate some traffic
curl http://localhost:8080/ ; curl http://localhost:8080/api/users/42

# 3. Verify Beyla emitted metrics — should list http_server_request_duration_seconds + counters
curl -s http://localhost:8999/metrics | grep -E '^http_(server|client)_request_duration'

# 4. Verify traces — in Grafana Explore on Tempo, search by service.name (default = process name)
#    Or: query Tempo's search API for spans with service.name="<app>"
2. Deploy as a cluster-wide DaemonSet

Full DaemonSet + RBAC YAML lives in references/kubernetes.md. After applying:

# 1. Verify DaemonSet rollout
kubectl -n monitoring rollout status ds/beyla

# 2. Verify pods are Running, one per node
kubectl -n monitoring get pods -l app=beyla -o wide

# 3. Verify eBPF probes attached (no errors mentioning BTF or "permission denied")
kubectl -n monitoring logs ds/beyla --tail=50 | grep -Ei 'error|fail|btf' || echo "clean"

# 4. Verify telemetry is flowing — check the Tempo/Alloy receiver for spans from the cluster
#    Or scrape one pod directly:
kubectl -n monitoring port-forward ds/beyla 8999:8999 &
curl -s localhost:8999/metrics | head
3. Send to Grafana Cloud via Alloy
# beyla-config.yml
otel_traces_export:  { endpoint: http://alloy:4318 }
otel_metrics_export: { endpoint: http://alloy:4318 }
# Verify Alloy is forwarding — check Alloy UI (localhost:12345) for the
# otelcol.receiver.otlp.beyla component showing received spans/metrics > 0.

Full Alloy + Beyla YAML: references/config.md.

Troubleshooting

  • failed to load BPF object → kernel < 5.8 or BTF missing; check /sys/kernel/btf/vmlinux

  • No spans in Tempo, but Prometheus metrics show → check OTEL_EXPORTER_OTLP_ENDPOINT, protocol (http vs grpc), and ports (4318 http / 4317 grpc)

  • HTTP route cardinality explosion → set routes.unmatched: heuristic and add patterns (see references/config.md)

  • Pod restarts with CrashLoopBackOff → likely missing hostPID: true or privileged: true / required capabilities

Resources

Files

ATTRIBUTION.md

Attribution

This folder is an unmodified copy of the Agent Skill "beyla", distributed by AutoGineer (https://autogineer.com/agent-skills).

The skill's own files are unmodified copies. AutoGineer is not affiliated with or endorsed by the author or the publisher.

Files added by AutoGineer

  • ATTRIBUTION.md: this file, written by AutoGineer

  • LICENSE: copied from LICENSE

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs network access, Needs a command-line tool, Needs Node.js

Security

What our scanner noticed· Low risk

  • Instructions that use the network

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Grafana Labs
Publisher
Grafana Labs (Official)
Source
grafana/skills · skills/grafana-core/beyla · commit 8fb72a5
Licence
Apache License 2.0 (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Grafana Labs.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download beyla.zip