Наблюдаемость через eBPF: профилирование и трейсинг без инструментирования

Beyla против OTEL SDK на одном Go-сервисе и eBPF-профилировщик Alloy против заданной доли CPU — всё против счёта генератора. Сколько запросов, статусов, gRPC- и SQL-вызовов увидел каждый, как Beyla называет маршрут без шаблона, почему SQL-спаны оказываются в трейсе без родителя, сколько запросов теряется сразу после прицепления, какие сборки Go профилировщик не символизирует и как на arm64 из профиля пропадает вызывающая функция. И сколько срабатываний eBPF-программ стоит один запрос

Классический способ увидеть, что делает сервис, — инструментировать код: добавить трейсы, метрики, профилировщик, пересобрать, выкатить. 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.

Ссылки

Обсуждение в Telegram

Присоединиться →