Last updated: September 1, 2025
Code Red Newsletter #3
Hi there,
Welcome back to your bi-weekly hit of observability goodness!
Whether you're knee-deep in distributed tracing or trying to see the truth in your logs like Neo staring at the Matrix code - we’ve got your back.
In Focus: Tracing
Tracing is like a detective story, except instead of solving a mystery, you’re proving to your colleagues that yes, the problem is in the database (again). This issue is packed with insights on making tracing easier, more consistent, and more automatic - so you spend less time chasing ghosts in your telemetry and more time actually fixing things.
Service Mesh Academy: Tracing with OpenTelemetry and Linkerd
What happens when you combine OpenTelemetry with Linkerd? Observability magic - or at least a much better way to see what your service mesh is doing.
In this Service Mesh Academy session, Michele Mancioppi from Dash0 and Flynn from Buoyant break down how Linkerd integrates with OpenTelemetry to provide seamless tracing.
Expect deep dives into distributed tracing, OpenTelemetry instrumentation, and practical demos - because let’s be honest, nothing beats seeing tracing in action without manually adding spans like it’s 2015.
Watch the session here.
TAG Observability: Ted Young on the Future of Observability
Ted Young breaks down the past, present, and future of OpenTelemetry, plus why the "three pillars of observability" is a terrible metaphor (his words, not mine).
If you’re wondering where observability is headed and why OpenTelemetry is still just getting started - this talk is worth your time.
Automatic OpenTelemetry Schema Migrations: Fix Your Tracing Data Without Lifting a Finger
Telemetry is only useful if it’s consistent. If half of your services use http.status_code while others use http.response.status_code, you’re in for a bad time. Dash0’s automatic schema migrations ensure your telemetry follows OpenTelemetry’s latest conventions - so you can focus on insights, not syntax.
Read more here.
Code RED Podcast: Why Tracing Matters with Michele Mancioppi
Tracing isn’t just collecting spans - it’s your best shot at cutting through the noise and finding the real issue before your coffee gets cold.
In this episode, Michele Mancioppi joins Mirko Novakovic to unpack why tracing is the backbone of modern observability and how OpenTelemetry’s Collector and semantic conventions clean up the chaos of inconsistent telemetry.
Context is king, and tracing - done right - connects logs, metrics, and spans into a coherent story instead of a frustrating puzzle. If you’ve ever been stuck staring at telemetry that refuses to add up, this episode will show you how modern tracing turns “code red” into real answers - fast.
Listen here.
Exploring OpenTelemetry Go Automatic Instrumentation with eBPF
Go’s compiled nature has always made auto-instrumentation a challenge, but eBPF changes that. OpenTelemetry can now dynamically capture function calls at runtime without modifying application code.
This approach brings significant benefits, including automatic tracing of HTTP, gRPC, and database interactions. However, it requires elevated privileges, meaning it may not be suitable for security-hardened environments.
The project is still in beta, so there may be rough edges and evolving APIs. Additionally, trace-context propagation must still be handled manually for full end-to-end visibility.
The Ultimate Guide to Sampling in OpenTelemetry
If you’re capturing every single trace, you’re either burning through storage or about to get a call from Finance. Sampling helps you keep what matters while controlling costs, but choosing the right strategy isn’t always obvious.
Henrik Rexed from Is It Observable breaks down head vs. tail sampling, best practices, and how to avoid losing the traces you actually need.
Don’t sample blindly; watch it here.
Choice Cuts: The Best of What’s New
New OpenTelemetry Demo Application: A Hands-on Playground for Observability
The OpenTelemetry Demo 2.0 is here. This revamped demo provides a full-stack, multi-language example of how to instrument an application with OpenTelemetry, now with a React Native example app and Valkey replacing Redis for in-memory storage.
Whether you’re looking to test new instrumentation techniques, validate configurations, or just get a hands-on feel for how OpenTelemetry works in a realistic setup, this is the best place to start.
Try it out here.
Best Practices for OpenTelemetry Service Attributes
Resource attributes turn raw telemetry into actionable insights. A well-structured service.name, service.namespace, and service.version can mean the difference between quick troubleshooting and hunting through logs at 3 AM.
Use consistent naming, group services logically, and track deployments with service.version to avoid debugging nightmares. Want to ensure your telemetry is always clear and structured? Follow these best practices.
Learn more here.
See You in Two Weeks
That’s it for this installment of the Code RED Newsletter. Tracing has come a long way, but as OpenTelemetry continues to evolve, we’re just scratching the surface of what’s possible.
From automatic instrumentation with eBPF to schema migrations that keep your telemetry future-proof, OpenTelemetry is making tracing easier, more scalable, and more powerful than ever.
Expect even more innovation ahead, and as always, we’ll be here to bring you the latest insights.
See you in two weeks for more cool stuff about observability, cloud-native, and all those little neat things that make the life of computer people that much more interesting.
Kasper, out.
