Open-Source Observability · open-telemetry

opentelemetry-go-instrumentation

OpenTelemetry Go Automatic Instrumentation is a work-in-progress project that automatically collects tracing data from Go applications using eBPF, a Linux kernel feature. It requires no code changes to the application and is deployed as a system-level agent, making it useful for observability in containerized and on-premises Go environments.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/open-telemetry/opentelemetry-go-instrumentation

GitHub stars

143

Forks

Primary language

Apache-2.0

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	open-telemetry/opentelemetry-go-instrumentation
Owner	open-telemetry
Primary language	C
License	Apache-2.0 — OSI-approved
Stars	1k
Forks	143
Open issues	119
Latest release	v0.24.0 (2026-04-27)
Last updated	2026-07-08
Source	https://github.com/open-telemetry/opentelemetry-go-instrumentation

What opentelemetry-go-instrumentation is

This Apache-licensed project instruments Go libraries via eBPF probes to collect distributed tracing telemetry without modifying application code. It is actively maintained, tested on Go 1.24–1.25 and Linux kernels ≥4.4, and outputs traces compatible with the OpenTelemetry standard. ARM64 support exists but lacks automated testing.

Quickstart

Get the opentelemetry-go-instrumentation source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/open-telemetry/opentelemetry-go-instrumentation.git2cd opentelemetry-go-instrumentation3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Observability for legacy Go services without code instrumentation

Automatically inject tracing into existing Go applications deployed on Linux without requiring recompilation or code changes, reducing time-to-observability.

Kubernetes and containerized Go workload monitoring

Deploy as a DaemonSet or sidecar in Kubernetes to capture distributed traces across microservices clusters, leveraging eBPF's kernel-level access for minimal overhead.

Production observability for closed-source or third-party Go binaries

Instrument compiled Go programs where source code is unavailable or modification is infeasible, enabling full tracing without access to the application codebase.

Implementation considerations

Requires Linux kernel ≥4.4 with eBPF support; verify kernel capabilities and container runtime compatibility (cgroups v2 awareness).
ARM64 has no automated testing; validate thoroughly in pre-production on ARM before rolling to production.
Project is explicitly marked 'work in progress'; expect API changes, incomplete feature coverage, and potential breaking updates in minor releases.
Only tested on Ubuntu amd64 and arm64; behavior on other Linux distributions (RHEL, Alpine, etc.) is not documented and requires validation.
Instrumentation coverage is package-specific; review COMPATIBILITY.md to confirm your target Go libraries are supported before committing to adoption.

When to avoid it — and what to weigh

Non-Linux operating systems required — eBPF is Linux-specific. macOS, Windows, and other non-Linux systems require Docker or VM workarounds, adding operational complexity.
Real-time, sub-millisecond tracing latency is critical — Kernel-level instrumentation adds overhead. Measure performance impact in your specific workload; not suitable for ultra-low-latency trading or real-time systems without validation.
Older Go versions (< 1.24) must be supported — The project only tests and supports current Go release versions. Legacy applications on older Go versions may face compatibility issues or lack of security updates.
Metrics and profiling are primary observability needs — This project focuses on tracing. If you need metrics, CPU profiling, or memory analysis, pair it with separate tooling or use a broader observability platform.

License & commercial use

Licensed under Apache License 2.0, a permissive OSI-approved license permitting commercial use, modification, and distribution with attribution and liability disclaimer.

Apache-2.0 explicitly permits commercial use. No proprietary restrictions, vendor lock-in, or commercial license required. You may use, modify, and redistribute in commercial products provided you retain the license header and do not claim warranty. Consult your legal team for your specific use case.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Active
Documentation	Adequate
License clarity	Clear
Deployment complexity	Moderate
DEV.co fit	Good
Assessment confidence	High

Security considerations

eBPF instrumentation runs in kernel space with CAP_SYS_ADMIN or CAP_PERFMON, requiring strong access controls in multi-tenant or hostile environments. No published security audit or vulnerability disclosure process noted in the data. Review kernel eBPF security patches and validate verifier behavior. Trace data collection may capture sensitive information (URLs, parameters); implement trace sampling and redaction policies at the collector level. Project is 'work in progress'; audit code and test thoroughly before production use.

Alternatives to consider

Manual OpenTelemetry SDK instrumentation (opentelemetry-go)

Requires code changes but offers full control, works on all OS platforms, and is production-stable. Choose if you can modify application source or build pipelines.

Datadog APM or New Relic with Go agents

Proprietary, managed SaaS solutions with built-in observability. Offer wider language support, metrics, and profiling. Choose if you prefer vendor-managed infrastructure and can accept lock-in.

Istio or Linkerd service mesh tracing

Provides automatic tracing at the network layer for Kubernetes workloads without application changes. Choose if observability is needed at the mesh level and you're already investing in service mesh infrastructure.

Software development agency

Build on opentelemetry-go-instrumentation with DEV.co software developers

OpenTelemetry Go Instrumentation enables production tracing without code changes on Linux. Validate Linux kernel and Go version compatibility, review COMPATIBILITY.md for supported libraries, and test on staging before deployment. Contact us to plan your observability strategy.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

opentelemetry-go opentelemetry-collector opentelemetry-rust

Related on DEV.co

Explore the category and the services that help you build with it.

Open-Source Observability DevOps & Observability Application Development (Go)Cloud Deployment (Linux/Kubernetes)Talk to DEV.co

opentelemetry-go-instrumentation FAQ

Does this work on macOS or Windows?

No. eBPF is Linux-only. macOS and Windows users must run it in Docker, a virtual machine, or use manual instrumentation instead.

Will this instrument my custom Go code without changes?

Yes, for supported Go standard library packages and common frameworks (documented in COMPATIBILITY.md). Custom internal libraries are not auto-instrumented; you may need manual instrumentation for those.

What is the performance overhead?

Not documented in the provided data. eBPF typically adds 1–10% overhead depending on trace sampling and kernel version. Measure in your environment before production rollout.

Can I use this on ARM64?

Yes, but without automated testing. Validate thoroughly in staging before production use on ARM-based systems.

Custom software development services

DEV.co is a software development agency delivering custom software development services to companies building on open source. Our software developers and web developers design, integrate, and ship production systems — spanning web development, APIs, AI, data, and cloud. If opentelemetry-go-instrumentation is part of your open-source observability roadmap, our team can implement, customize, migrate, and maintain it.

Ready to instrument your Go services automatically?

Talk to DEV.co Schedule a Consultation