Telemetry Without Tears: Instrumentation Patterns for Go Developers

Modern observability relies heavily on telemetry, but many developers use instrumentation libraries without understanding how they actually work. In Go, instrumentation presents unique challenges due to the language's compilation model, runtime characteristics, and lack of traditional bytecode-based agents.

This talk explores the fundamentals of telemetry and OpenTelemetry, compares manual and automatic instrumentation approaches, and explains the mechanisms that make them possible. We'll dive into the challenges of instrumenting Go applications, discuss why techniques commonly used in Java don't directly apply, and examine emerging approaches such as compile-time instrumentation.

Attendees will gain a practical understanding of how instrumentation works under the hood, the trade-offs between different approaches, and how to choose the right strategy for their own Go services. The session will include real-world examples and lessons learned from building and operating observability tooling in production environments.

• Understand the core concepts of telemetry and the three pillars of observability: metrics, logs, and traces.

• Learn how OpenTelemetry standardizes instrumentation and data collection across applications and platforms.

• Understand the difference between manual instrumentation, automatic instrumentation, and compile-time instrumentation.

• Gain insight into how automatic instrumentation works under the hood and why it is easier in some ecosystems (such as Java) than others.

• Learn the unique challenges of instrumenting Go applications, including the impact of static compilation, runtime characteristics, and deployment constraints.

• Understand the trade-offs between instrumentation approaches in terms of developer effort, performance overhead, operational complexity, and observability coverage.

• Discover emerging techniques and open-source projects that enable instrumentation without requiring application code changes.