BCD – Backtrace Debugger and Aggregator w praktyce

Wprowadzenie

W świecie Linuksa i oprogramowania systemowego debugowanie błędów jest codziennością. Standardowe narzędzia, takie jak gdb czy core dump, bywają ciężkie w użyciu i generują ogromne pliki.

BCD (Backtrace Debugger and Aggregator) to projekt stworzony przez Backtrace Labs, który ma na celu uproszczenie procesu zbierania informacji o błędach i ich automatyczną agregację.

BCD działa jako biblioteka i narzędzie systemowe, które można podpiąć do aplikacji. W momencie wystąpienia błędu (np. segmentation fault) BCD uruchamia zewnętrzne narzędzia i tworzy snapshot procesu – czyli lekką migawkę stanu aplikacji. Następnie dane mogą być przesłane do bazy Backtrace lub innego systemu analitycznego.

Dlaczego warto się zainteresować?

• Lekkość i szybkość – zamiast pełnych core dumpów, BCD generuje zwięzłe snapshoty.
• Automatyzacja – błędy są zbierane i agregowane bez ręcznej interwencji.
• Integracja – można podpiąć BCD do systemów CI/CD, monitoringu czy baz danych.
• Obsługa wielu kompilatorów – GCC, Clang, ICC są wspierane.
• Kompatybilność z C++ – choć wymaga kompilatora wspierającego GNU99, interfejs jest zgodny z C++.

Instalacja

BCD jest dostępny na GitHubie: backtrace-labs/bcd. Instalacja przebiega klasycznie:

# Pobranie repozytorium
git clone https://github.com/backtrace-labs/bcd.git
cd bcd

# Konfiguracja
./configure

# Kompilacja
make

# Instalacja systemowa
sudo make install

Dla starszych wersji glibc (< 2.17) wymagane jest dodatkowe wsparcie librt.

Podstawowe użycie

BCD można uruchomić na dwa sposoby:

1. Preload (bez modyfikacji kodu źródłowego) Dzięki mechanizmowi LD_PRELOAD można podpiąć BCD do istniejącej aplikacji:bashLD_PRELOAD=/usr/local/lib/libbcd.so ./moja_aplikacja W przypadku awarii snapshot zostanie automatycznie wygenerowany.
2. Integracja w kodzie źródłowym Można włączyć BCD jako bibliotekę w projekcie:c#include <bcd.h> int main() { bcd_enable(); // kod aplikacji } W momencie błędu snapshot zostanie zapisany i przesłany do systemu analizy.

Typowy przykład użycia z językiem C:

#include <bcd.h>
#include <stdio.h>
#include <stdlib.h>

int main(void) {
	struct bcd_config config;
	bcd_error_t error;
	bcd_t bcd;

	/* Initialize BCD configuration. See bcd.h for options */
	if (bcd_config_init(&config, &error) == -1)
		goto fatal;

	/* Initialize the library. */
	if (bcd_init(&config, &error) == -1)
		goto fatal;

	/* Initialize a handle to BCD. This should be called by every thread interacting with BCD. */
	if (bcd_attach(&bcd, &error) == -1)
		goto fatal;

	if (bcd_kv(&bcd, "application", "my_application", &error) == -1)
		goto fatal;

	if (bcd_kv(&bcd, "datacenter", "my data center", &error) == -1)
		goto fatal;

	/*
	 * Generate a snapshot of the calling thread and upload it to
	 * the Backtrace database. Key-value attributes will be included.
	 */
	bcd_emit(&bcd, "This is a non-fatal error");

	/*
	 * We generate a fatal error and exit immediately.
	 */
	bcd_fatal("This is a fatal error. No recovery");
	return 0;
fatal:
	fprintf(stderr, "error: %s\n",
	    bcd_error_message(&error));
	exit(EXIT_FAILURE);
}

Przykładowe komendy

• Uruchomienie aplikacji z BCD:
  • bcd-run ./moja_aplikacja
• Generowanie snapshotu ręcznie:
  • bcd-dump --pid 12345
• Agregacja danych:
  • bcd-aggregate /var/log/bcd/
• Preładowanie – ang. preloading:
  • BCD_PRELOAD=1 LD_PRELOAD=/opt/backtrace/lib/libbcd_preload.so ./program [BCD] Initializing BCD... program.264261.1605471835.btt Aborted (core dumped)

Konteksty użycia

BCD sprawdzi się szczególnie w:

• Systemach produkcyjnych, gdzie nie można pozwolić sobie na pełne core dumpy.
• Embedded Linux, gdzie zasoby są ograniczone.
• CI/CD, aby automatycznie zbierać błędy podczas testów.
• Analizie awarii w aplikacjach serwerowych, gdzie snapshoty można przesyłać do centralnej bazy.

Podsumowanie

BCD to narzędzie, które upraszcza debugowanie w Linuksie, pozwalając na szybkie i lekkie zbieranie informacji o błędach. Instalacja jest prosta, a użycie elastyczne – od preloadu po integrację w kodzie. Dzięki temu można znacząco skrócić czas diagnozy i poprawić stabilność aplikacji.