features.md

Supported Protocols

This section describes language-agnostic protocol instrumentation. Some context propagation support is only available through language-specific library instrumentation documented later in this file.

Protocol	Languages	Versions	Methods	Secure	Propagates Context	Limitations
HTTP	All	1.0/1.1	All	Yes	Yes	N/A
HTTP	All	2.0	All	Yes	No	Context propagation for HTTP/2 is only through Go library instrumentation
gRPC	All	1.0+	All	Yes	Yes	Can't get method for long living connections before OBI started, will mark method with *
MySQL	All	All	All	Yes	No	In the case of prepared statements, if the statement was prepared before OBI started then the query might be missed
PostgreSQL	All	All	All	Yes	No	In the case of prepared statements, if the statement was prepared before OBI started then the query might be missed
MSSQL	All	All	All	Yes	No	In the case of prepared statements, if the statement was prepared before OBI started then the query might be missed
Redis	All	All	All	Yes	No	For already started connections, can't infer the number of the database, and won't add the db.namespace attribute
MongoDB	All	5.0+	insert, update, find, delete, findAndModify, aggregate, count, distinct, mapReduce	Yes	No	no support for compressed payloads
Couchbase	All	All	All	Yes	No	Bucket unknown if SELECT_BUCKET occurred before OBI started; Collection unknown if GET_COLLECTION_ID occurred before OBI started
Memcached	All	All	ASCII text subset (excludes quit and meta commands)	Yes	No	Only the first key is recorded for multi-key retrieval commands; payload bytes are not captured
Kafka	All	All	produce, fetch	Yes	No	Might fail getting topic name for fetch requests in newer versions of kafka (where Fetch api version >= 13)
MQTT	All	3.1.1/5.0	publish, subscribe	No	No	For subscribe, only first topic filter is used; payload not captured
NATS	All	All	publish, process	No	No	Only PUB/HPUB and delivered MSG/HMSG frames are traced; control traffic is ignored
AMQP	All	1.0	publish, process	No	No	Userspace heuristic only; transfer frames are traced while handshake and flow-control performatives are ignored
SunRPC (ONC RPC)	All	All	CALL procedures on known TCP programs (for example portmapper, mount, nfs)	Yes	No	TCP only; kernel + userspace fallback; RPCSEC_GSS hides arguments; procedure names not mapped yet
GraphQL	All	All	All	Yes	No	N/A
JSON-RPC	All	2.0	All	Yes	No	Requires HTTP payload capture enabled (OTEL_EBPF_BPF_BUFFER_SIZE_HTTP) and OTEL_EBPF_HTTP_JSONRPC_ENABLED=true
Elasticsearch	All	7.14+	/_search, /_msearch, /_bulk, /_doc	Yes	No	N/A
Opensearch	All	3.0.0+	/_search, /_msearch, /_bulk, /_doc	Yes	No	N/A
AWS S3	All	All	CreateBucket, DeleteBucket, PutObject, DeleteObject, ListBuckets, ListObjects, GetObject	Yes	No	N/A
AWS SQS	All	All	All	Yes	No	N/A
SQL++	All	All	All	Yes	No	N/A
GenAI	All	All	All	Yes	No	Supported vendors: OpenAI, Anthropic, Google AI Studio (Gemini), AWS Bedrock, Qwen (DashScope), generic embedding providers (Voyage AI, Cohere, Jina AI), Cohere (Rerank), Jina AI (Rerank), Voyage AI (Rerank), Qwen (DashScope) (Rerank), vector retrieval (Pinecone, Qdrant, Milvus, Zilliz, Chroma, Weaviate)

Go Instrumentation

Specifically for Go applications, OBI chooses to instrument libraries directly using Uprobes, instead of instrumenting at the network level. This allows for more accurate tracing and context propagation. This set of instrumentations currently replaces all the network level instrumentation for Go applications. To turn this off and fallback to the normal network based instrumentation for Go processes, you set discovery.skip_go_specific_tracers to true in the config, or set the environment variable OTEL_EBPF_SKIP_GO_SPECIFIC_TRACERS=true.

Library	Protocol	Versions	Methods	Secure	Propagates Context	Limitations
net/http	HTTP	>= 1.17	All	Yes	Yes	N/A
golang.org/x/net/http2	HTTP	>= 0.12.0	All	Yes	Yes	N/A
github.com/gorilla/mux	HTTP	>= v1.5.0	All	Yes	Yes	N/A
github.com/gin-gonic/gin	HTTP	>= v1.6.0,!= v1.7.5	All	Yes	Yes	N/A
google.golang.org/grpc	gRPC	>= 1.40	All	Yes	Yes	N/A
net/rpc/jsonrpc	JsonRPC	>= 1.17	All	Yes	No	N/A
database/sql	SQL	>= 1.17	All	Yes	No	N/A
github.com/go-sql-driver/mysql	MySQL	>= v1.5.0	All	Yes	No	N/A
github.com/lib/pq	PostgreSQL	All	All	Yes	No	N/A
github.com/redis/go-redis/v9	Redis	>= v9.0.0	All	Yes	No	N/A
github.com/segmentio/kafka-go	Kafka	>= v0.4.11	All	Yes	No	N/A
github.com/IBM/sarama	Kafka	>= 1.37	All	Yes	No	N/A
go.mongodb.org/mongo-driver	MongoDB	>= v1.10.1, >= v2.0.1	All	Yes	No	N/A

Payload Capture

OBI can capture full request and response payloads for some protocols and forward them to userspace for richer analysis (e.g. SQL body extraction, Kafka Metadata parsing). This feature is disabled by default.

Each limit is applied per request and per direction independently: the configured value caps the total bytes captured for the request direction and, separately, the total bytes captured for the response direction. For example, OTEL_EBPF_BPF_BUFFER_SIZE_HTTP=4096 captures up to 4096 bytes of request body and up to 4096 bytes of response body. Large payloads are streamed to userspace across multiple ring-buffer events and reassembled there.

Environment variable	Protocol	Maximum	Default
OTEL_EBPF_BPF_BUFFER_SIZE_HTTP	HTTP	262144	0 (disabled)
OTEL_EBPF_BPF_BUFFER_SIZE_MYSQL	MySQL	65535	0 (disabled)
OTEL_EBPF_BPF_BUFFER_SIZE_KAFKA	Kafka	65535	0 (disabled)
OTEL_EBPF_BPF_BUFFER_SIZE_POSTGRES	PostgreSQL	65535	0 (disabled)
OTEL_EBPF_BPF_BUFFER_SIZE_MSSQL	MSSQL	65535	0 (disabled)

Equivalent YAML keys live under ebpf.buffer_sizes.{http,mysql,kafka,postgres,mssql}.

GPU Instrumentation

Specifically for instrumenting GPU execution primitives, like NVIDIA CUDA kernel launches and memory copies. This instrumentation support differs from traditional GPU metrics, such as GPU utilization and GPU temperature.

Library	Primitives	Versions	Limitations
libcuda	cudaLaunchKernel, cudaGraphLaunch, cudaMalloc, cudaMemcpy, cudaMemcpyAsync	>= 7.0	N/A

Supported Context propagation frameworks

For Inter-process context propagation, OBI by default assumes actions happening the same thread are part of the same trace. but in many cases, especially in asynchronous programming models, the context might be propagated across threads or even processes. OBI has support for several asynchronous frameworks that allow it to propagate context in these scenarios.

Framework	Languages	Versions	Limitations	Status
Go Routines	Go	Go >= 1.18	up to 3 nested levels of goroutines	Stable
Node.js Async Hooks	Node.js	Node.js >= 8.0	Custom handling of SIGUSR1 signal might interfere	Stable
Ruby Puma Server	Ruby	N/A	Only works with Puma server	Stable
Java Thread pool	Java	JDK 8+	N/A	Stable
Java Virtual Threads	Java	JDK 21+	Log enrichment is skipped on virtual threads	Stable
Python asyncio	Python	Python >= 3.9	Only works with uvloop event loop	Stable