Классический способ увидеть, что делает сервис, — инструментировать код: добавить трейсы, метрики, профилировщик, пересобрать, выкатить. eBPF предлагает другой заход: наблюдать за процессом из ядра, не трогая приложение. Профиль снимается с работающего бинаря, HTTP-запросы видны без единой строки нового кода.
Обещание звучит как «то же самое, только бесплатно». Эта статья проверяет его счётом. Генератор отправляет на сервис известное число запросов по маршрутам и печатает, что отправил. Один экземпляр сервиса наблюдает Beyla через eBPF, второй инструментирован OTEL SDK; оба отдают трейсы в один коллектор, и коллектор пишет их в файл. Профили — eBPF-профилировщик Grafana Alloy против процесса, который сам знает, какую долю CPU тратит в какой функции.
Вторая статья серии «eBPF на практике». Фундамент — карты, точки подключения, ловушки uprobe на Go — в первой статье; инструментирование кода — в статье про OTEL SDK, профилирование через SDK — в статье про Pyroscope.
В статье
- Стенд
- Сколько увидел каждый
- Чего не видно в счёте
- Профилирование без кода
- Цена
- Как выбирать
- Чего эти результаты не значат
Стенд
Go-сервис: GET /users/{id} с запросом SELECT в PostgreSQL, POST /orders с
INSERT, GET /fail, который отвечает 500, GET /health, gRPC health-check и
отдельный порт 8081, где путь /v2/users/<id> разбирает сам обработчик — без
шаблона маршрута, как в самописных роутерах. Сборка без инструментирования
(svc-plain) — её видит Beyla 3.38. Сборка с OTEL SDK (svc-sdk) — те же
маршруты через otelhttp, otelgrpc и otelsql:
// svc/otel.go
instrumentHandler = func(route string, h http.Handler) http.Handler {
return otelhttp.NewHandler(h, route, otelhttp.WithSpanNameFormatter(
func(_ string, r *http.Request) string { return r.Method + " " + route }))
}
Beyla — отдельный привилегированный контейнер; процесс она находит по пути исполняемого файла:
# compose.yml
environment:
BEYLA_AUTO_TARGET_EXE: "*/svc-plain"
OTEL_SERVICE_NAME: svc-beyla
План генератора — 950 HTTP-запросов по пяти маршрутам и 150 gRPC-вызовов,
всего 1100 обращений;
/users/{id} и /v2/users/<id> — каждый раз с новым id.
Сколько увидел каждый
Постановка. Генератор отправляет один и тот же план на обе сборки. Счёт — серверные спаны по маршрутам и статусам ответа против отправленного. Контроль — OTEL SDK.
Первый прогон дал Beyla 195 серверных спанов из 1100 ожидаемых (950 HTTP и
150 gRPC) и ни одного SQL-спана.
Нагрузка стартовала сразу после строки instrumenting process в журнале Beyla, а
зонды к этому моменту ещё не работали: Beyla увидела только хвост — gRPC и
последние запросы на порт 8081. Строка в журнале означает «начала цеплять», а
не «уже видит». Поэтому раннер перед нагрузкой шлёт запросы на служебный
/warmup, пока такой спан не появится в выгрузке коллектора; прогрев в счёт
не входит. После прогрева:
| маршрут | отправлено | Beyla | OTEL SDK |
|---|---|---|---|
GET /users/{id} |
200: 300 | 200: 300 | 200: 300 |
POST /orders |
201: 200 | 201: 200 | 201: 200 |
GET /fail |
500: 50 | 500: 50 | 500: 50 |
GET /health |
200: 100 | 200: 100 | 200: 100 |
GET /v2/users/{id} |
200: 300 | 200: 300 | 200: 300 |
/grpc.health.v1.Health/Check |
OK: 150 | OK: 150 | OK: 150 |
Контроль сошёлся: OTEL SDK насчитал каждый маршрут и статус ровно по счёту генератора.
Beyla совпала с генератором так же точно — по каждому маршруту, статусу и gRPC-вызову, без строки кода в сервисе. Это главный результат: после прогрева счёт запросов у eBPF-инструментирования не хуже, чем у SDK.
Чего не видно в счёте
Счёт совпал, но трейс — это ещё имена и связи.
$ python3 scripts/run-traces.py beyla-route-names
{"variant": "beyla-route-names", "outcome": "match", "detail": ":8080 — /fail, /health, /orders, /users/{id}; :8081 — 300 разных путей → /v2/users/*"}
Имя маршрута Beyla взяла из шаблона, с которым маршрут зарегистрирован в
http.ServeMux, — /users/{id}, а не /users/258419. На порту без шаблона
300 разных путей свернулись эвристикой в одно имя /v2/users/*: кардинальность
не взорвалась, но имя приблизительное. В SDK имя маршрута задаёт программист —
и оно точно такое, каким его написали.
| что | Beyla | OTEL SDK |
|---|---|---|
| SQL SELECT / INSERT | 300 / 200 | 300 / 200 |
CREATE TABLE при старте сервиса |
не виден | виден |
| SQL-спанов в трейсе HTTP-запроса | 500 из 500 | 500 из 500 |
| SQL-спанов с найденным родителем | 0 из 500 | 500 из 500 |
| служебных спанов на HTTP-запрос | 2 | 0 |
$ python3 scripts/run-traces.py beyla-links
{"variant": "beyla-links", "outcome": "mismatch", "detail": "SQL-спанов 500: в трейсе HTTP-запроса 500, родитель найден 0"}
$ python3 scripts/run-traces.py sdk-links
{"variant": "sdk-links", "outcome": "match", "detail": "SQL-спанов 500: в трейсе HTTP-запроса 500, родитель найден 500"}
SQL-спаны Beyla попадают в тот же трейс, что HTTP-запрос, — трейс группируется. Но поле родителя у них указывает на спан, которого в выгрузке нет, и дерево трейса рвётся: просмотрщик покажет запрос к базе без родителя, а не под обработчиком. У SDK каждый SQL-спан — потомок своего HTTP-спана.
Ещё два отличия. SDK увидел CREATE TABLE, который сервис выполняет при
старте, — Beyla цепляется к новому процессу позже и его не видела: всё, что процесс сделал до
прицепления, для eBPF не существует. И у Beyla на каждый HTTP-запрос два
служебных спана — in queue и processing: время ожидания в очереди сервера и
время обработки, которых SDK не показывает.
Профилирование без кода
eBPF-профилировщик много раз в секунду снимает стек каждого процессора
и превращает адреса в имена функций. Второе — самое хрупкое: имена берутся из
таблиц внутри бинаря, и у Go их две — обычная таблица символов ELF и
собственная pclntab, которую рантайм Go держит всегда, даже в бинаре,
собранном с -ldflags="-s -w".
Постановка. Процесс делает 3 итерации в burnA на каждую итерацию в
burnB — эталон 75% и 25% CPU, допуск ±5 п.п. записан до прогона. Один и тот
же код собран тулчейнами Go 1.26 и 1.27, с символами и без. Профиль — окно
90 секунд в Pyroscope. Контроль — Go 1.26 с символами.
| сборка | профилировщик о версии Go | burnA (эталон 75%) | burnB (эталон 25%) |
|---|---|---|---|
| Go 1.26, с символами | поддержан | 75,6% | 24,2% |
Go 1.26, -s -w |
поддержан | 75,5% | 24,2% |
| Go 1.27, с символами | unsupported | 75,3% | 24,3% |
Go 1.27, -s -w |
unsupported | нет в профиле | нет в профиле |
Go 1.26, общая листовая work |
поддержан | менее 1% | менее 1% |
тот же процесс, runtime/pprof (контроль) |
— (go1.26.9) | 75,0% | 25,0% |
Контроль сошёлся: у Go 1.26 с символами доли в допуске.
Go 1.26 профилировщик символизирует и без символов ELF — по pclntab. Go 1.27
он не поддерживает: в журнале Alloy 1.20 unsupported Go version go1.27.1 (need >= 1.13 and <= 1.26). С символами ELF имена всё равно есть, и доли в
допуске; без них — имён нет совсем. Профилировщик отстаёт от релизов Go, и
отставание видно не сразу: пока бинарь собран с символами, профиль выглядит
нормально.
Вариант go126-shared — ловушка другого рода. burnA и burnB вызывают общую
функцию work, в которой и крутится цикл:
$ python3 scripts/run-profiles.py go126-shared
{"variant": "go126-shared", "outcome": "mismatch", "detail": "burnA и burnB в профиле нет (меньше 1% CPU); больше всего собственного CPU — main.work (99.4%)"}
$ python3 scripts/run-profiles.py pprof-shared
{"variant": "pprof-shared", "outcome": "match", "detail": "runtime/pprof того же процесса (go1.26.9): burnA 75.0%, burnB 25.0% по полному времени (эталон 75 / 25, допуск ±5 п.п.)"}
Почти всё время — в work, а burnA и burnB из профиля пропали: вопрос
«какая из двух функций дороже» профиль не отвечает. work — листовая функция
без собственного кадра стека; на arm64 адрес возврата у неё лежит в регистре,
а не на стеке, и раскрутка по указателям кадров теряет прямого вызывающего. На
x86-64 инструкция вызова кладёт адрес возврата на стек, и эта причина там не
действует; на x86-64 стенд не прогонялся.
Контроль — runtime/pprof того же процесса: бинарь собран тем же Go 1.26, и
процесс снимает свой профиль сам все 130 секунд, перекрывая окно Alloy, — оба
профилировщика смотрят на одно и то же исполнение. Рантайм Go раскручивает
стек по своим таблицам и вызывающих не теряет: burnA и burnB по полному
времени в допуске 75 / 25. Потеря — свойство раскрутки
eBPF-профилировщика на arm64, а не профиля как такового.
Цена
eBPF-инструментирование не бесплатно: программы выполняются в ядре на каждом
событии, к которому прицеплены. Ядро умеет это считать —
kernel.bpf_stats_enabled=1 включает для каждой программы число срабатываний
(run_cnt) и суммарное время внутри (run_time_ns).
Постановка. Программы Beyla — те, что появились после её запуска. Два окна: 20 секунд без нагрузки (контроль — что программы делают на фоне) и план генератора. На запрос — разница счётчиков под нагрузкой за вычетом фона.
$ python3 scripts/run-cost.py idle
{"variant": "idle", "outcome": "match", "detail": "программ Beyla 164; за 20 с без нагрузки срабатываний 0 — меньше 1% срабатываний под нагрузкой"}
$ python3 scripts/run-cost.py load
{"variant": "load", "outcome": "match", "detail": "обращений (HTTP и gRPC) 1100: программ сработало 30 из 164, срабатываний на обращение 19, время в программах 9.8 мкс на обращение"}
Без нагрузки программы Beyla почти молчат: от нуля до нескольких десятков срабатываний за 20 секунд от сессии к сессии — меньше процента того, что они делают под нагрузкой. Под нагрузкой срабатывают несколько десятков программ из полутора сотен загруженных: каждый системный вызов сети и каждая инструментированная Go-функция запроса. Время в программах — порядка десяти–двадцати микросекунд на обращение (от сессии к сессии по-разному). Обращение здесь — один вызов смешанной нагрузки: HTTP или gRPC; знаменатель — все 1100. Это время ядра в eBPF-коде, а не прибавка к задержке запроса: задержку стенд не мерил, и она зависит от того, сколько CPU свободно.
Как выбирать
| что | на стенде | что делать |
|---|---|---|
| счёт запросов | Beyla = SDK = генератор по каждому маршруту | для «сколько и с каким статусом» eBPF достаточно |
| старт | сразу после прицепления Beyla видит не всё | проверять готовность по первому спану, а не по журналу |
| имена маршрутов | шаблон ServeMux — точно; без шаблона — эвристика /v2/users/* |
где роутер свой — задавать маршруты в конфигурации Beyla или SDK |
| дерево трейса | SQL в трейсе запроса, но без родителя | нужно дерево с бизнес-спанами — SDK |
| события до старта | CREATE TABLE при запуске Beyla не видит |
eBPF не заменяет логи старта |
| профили и версия Go | Go 1.27 не поддержан, без символов имён нет | не стрипать бинари или держать профилировщик не старше Go |
| листовые функции на arm64 | вызывающий пропал из профиля | помнить о ловушке при чтении профиля на arm64 |
| цена | фон меньше процента, около двадцати срабатываний на обращение | мерить своим сервисом: bpf_stats_enabled и bpftool prog |
eBPF и SDK — не соперники. eBPF даёт счёт и профиль сервиса, в код которого нельзя или некогда залезть, с первого дня. SDK даёт дерево трейса, бизнес-атрибуты и всё, что происходит до прицепления.
Чего эти результаты не значат
- Один сервис. Распространение контекста трейса между сервисами Beyla умеет, но здесь сервис один, и это не замерялось.
- Время в программах — не задержка запроса. Цена — счётчики ядра, а не нагрузочный тест.
- arm64. Пропавший вызывающий — особенность раскрутки на arm64.
- Версии важны. Поддержка Go в профилировщике и то, что видит Beyla, меняются от релиза к релизу.
- Версии: Beyla 3.38.0 (OBI 0.14.0), Alloy 1.20.1, Pyroscope 2.3.2, OTEL Collector contrib 0.162.0, OTEL Go SDK 1.47.0, Go 1.27.1 и 1.26.9, PostgreSQL 18.6, ядро 7.0.12-linuxkit, aarch64.
Ссылки
- Стенд: digital-cookbook/ebpf/observability — три оси, генератор и сжигатель с эталонным счётом.
- Grafana Beyla
- OpenTelemetry eBPF Instrumentation (OBI)
- Grafana Alloy: pyroscope.ebpf
- OpenTelemetry eBPF profiler
Обсуждение в Telegram
Присоединиться →