github.com/jaegertracing/jaeger

Integrating Jaeger into Go applications requires understanding both the jaeger-client-go library and OpenTracing/OpenTelemetry concepts, which can feel overwhelming initially. However, once you grasp the span creation patterns and context propagation, instrumenting services becomes straightforward. The documentation provides solid examples for common scenarios like HTTP middleware and database tracing, though you'll need to supplement with community resources for edge cases.

The real value emerges when debugging distributed systems. Being able to visualize request flows across microservices and identify bottlenecks is invaluable. Error messages are generally helpful, especially around configuration issues with samplers and reporters. The library handles connection failures gracefully with backoff, preventing tracing from bringing down your service.

One frustration is the transition period between OpenTracing and OpenTelemetry - you'll encounter both APIs in examples, causing confusion about best practices. GitHub issues get responses, though not always quickly. The collector setup and deployment require separate learning, but once running, the Go client integration is stable and performant.

Jaeger is the go-to solution for distributed tracing in microservices architectures. The initial setup requires understanding OpenTelemetry integration (the modern approach) or the legacy jaeger-client-go library. The documentation has improved significantly with OpenTelemetry becoming the standard, though finding the right integration path can still take some trial and error. The all-in-one Docker image makes local development painless.

Day-to-day usage is solid once configured. The UI is intuitive for trace visualization, and the Go client libraries handle span propagation well with context.Context patterns. Error messages when traces don't appear are often vague - you'll spend time checking sampling configs and network connectivity. The adaptive sampling strategies are powerful but require understanding probabilistic vs rate-limiting approaches.

Community support is good through GitHub issues, though responses can be slow for edge cases. The HotROD demo application is invaluable for understanding real-world instrumentation patterns. Debugging missing spans usually involves enabling debug logging and verifying propagation headers, which takes practice to master.

Jaeger as a distributed tracing system is solid, but integrating it into Go projects requires careful navigation. The SDK has been largely superseded by OpenTelemetry, and the docs frequently redirect you there, creating confusion about which APIs to use. If you're starting fresh, you'll find yourself implementing OpenTelemetry and just using Jaeger as the backend.

The native Jaeger client libraries work but feel dated. Configuration is verbose with many options spread across multiple structs. Error messages when spans aren't appearing are often opaque - you'll spend time debugging agent connectivity, sampling rates, and UDP buffer sizes. The getting-started examples are functional but don't cover common production scenarios like context propagation across goroutines or sampling strategies well.

IDE support is acceptable for basic usage, but the numerous configuration options and interfaces make it hard to discover what you actually need. The migration path from native Jaeger clients to OpenTelemetry isn't well documented, leaving teams to figure out compatibility layers themselves.