Last updated: September 1, 2025
Code Red Newsletter #12
Hi there,
Summer is in full swing, and while the world slows down just a little, the observability space keeps accelerating. We’re seeing a clear trend: automation is no longer a luxury - it’s becoming the baseline. Whether it’s injecting agents with zero code changes, auditing telemetry for quality, or enforcing compliance with a simple processor config, teams are getting serious about reducing toil without sacrificing visibility.
In this edition, we explore what it means to make observability automatic - from JVM agents and Linux injectors to pipeline enforcement and semantic validation. It’s about freeing up engineers to focus on what matters, while the platform quietly takes care of the rest.
Observability shouldn't feel like extra work. When done right, it just works.
In focus: Making Observability Automatic
Observability used to be something teams bolted on at the end. Now it’s getting baked in from the start. With OpenTelemetry’s expanding toolset, you can automate everything from agent injection to span enrichment, while still keeping control where it counts. Instrumentation is evolving - from handcrafted SDK wiring to Operator-managed sidecars to zero-touch injectors on the host. The result? Teams can move faster, observe more, and debug less, all while shipping code that’s ready for real-world complexity.
Bridging platform engineering and observability: Empowering developers with insights
At this year’s PlatformCon, I explored how platform engineering can make observability feel like a built-in feature, not an afterthought. The talk focuses on enabling self-service instrumentation for developers by treating observability as part of the platform contract.
With auto-instrumentation, semantic conventions, and collector pipelines, it becomes possible to unify traces, metrics, and logs across teams - without requiring every developer to be an observability expert. If you’re responsible for reducing friction between platforms and developers, this one’s for you.
OpenTelemetry Autoinstrumentation in Java
Observability in Java has come a long way from verbose SDK boilerplate and brittle span plumbing. In this deep dive, we explore the three paths to instrumentation - manual, auto, and zero-touch using the OpenTelemetry Operator.
You’ll learn how JVM introspection powers auto-instrumentation, how to add business context with @WithSpan or Span.current().setAttribute(), and when to enrich traces with hybrid strategies. The Operator brings platform-led rollout to life, injecting agents without touching Dockerfiles. And if something breaks? The guide also covers common pitfalls around startup time, context propagation, and noisy spans.
Implementing Compliance-first Observability with OpenTelemetry
Telemetry helps you debug problems. But without guardrails, it can also become a compliance problem in itself. This post walks through how to use OpenTelemetry Collector processors to redact PII, enforce routing rules, and standardize telemetry before it leaves your environment.
Whether you're governed by GDPR, HIPAA, or just want to avoid leaking sensitive fields into a shared backend, OpenTelemetry offers the knobs to do it. You'll learn how to use attributes, filter, and transform processors to shape your data, and how to treat the Collector as both a routing engine and a policy enforcement layer.
Code RED Podcast: Building Telemetry Pipelines for Petabyte-Scale Systems
Edge Delta’s Ozan Unlu joins Mirko to talk about the evolution of telemetry pipelines - from centralized blob stores to distributed, stream-based architectures that actually scale.
Ozan draws from his experience at Microsoft and Sumo Logic, sharing why data tiering, edge processing, and signal filtering are becoming critical to keeping costs low and insights sharp. They also explore how AI fits into the equation, from anomaly detection to automated triage. If you’ve ever asked yourself whether your current pipeline can handle what’s next, this episode brings perspective - and a few spicy takes.
Listen to the episode.
Judging Telemetry Quality using Weaver
Weaver is a tool from the OpenTelemetry project that helps you assess how well your telemetry aligns with defined semantic conventions - whether you're following the official spec or a custom one.
In this post, the focus is on using Weaver's validation feature to check spans and attributes for issues like deprecated fields, missing metadata, or type mismatches. The result is a structured report that can be useful in CI pipelines or platform reviews to catch inconsistencies before they propagate into dashboards or alerts.
Adding Automatic Instrumentation to Your App with the OpenTelemetry Injector
The OpenTelemetry Injector makes it possible to inject agents into your applications without touching the app code, Dockerfile, or startup scripts. Donated by Splunk and now part of the OpenTelemetry ecosystem, it works via systemd config or LD_PRELOAD to apply auto-instrumentation at the host level.
This is especially powerful in environments where you can’t modify container images or CI pipelines. It’s the next evolution in making observability not just easy - but invisible.
By the way: At Dash0, we are working to make the injector with use in the Dash0 Operator ready to be shared with the community.
Choice cuts
This week’s picks are strictly for your eyeballs - two standout videos worth queuing up between commits, Kubernetes restarts, or questionable coffee refills.
Is Dapr the Future of Microservices?
This session explores how Dapr is redefining microservice architectures with built-in service discovery, pub/sub, and telemetry. If your team is navigating the edge between platform abstraction and developer control, this might be the framework worth watching.
Check out the episode.
Scaling Observability with OpenTelemetry
Whitney Lee and Austin Parker walk through the origin, growth, and future of OpenTelemetry. From SDKs and semantic conventions to collector pipelines and context propagation, it’s a whirlwind tour of how OTel came to be - and where it’s going next.
That wraps up this issue of the Code RED Newsletter. What we’re seeing - clearly - is the rise of platform-led observability. One where instrumentation isn’t something engineers argue over in sprint planning, but something that just happens. One where telemetry isn’t just collected, but enriched, validated, and aligned to real-world use cases. Whether you're standardizing with semantic conventions, automating with Operators, or filtering telemetry before it hits your backend, the trend is clear: observability is growing up.
We’ll be back on August 8, due to vacation, with fresh content - but until then, keep watching the signals and shaping the platform beneath them. If you're attending WeAreDevelopers in Berlin or AWS Summit in New York, come say hi - we’ll be running demos at the Dash0 booth, and on Friday, July 11, catch our CEO, Mirko Novakovic, in a panel discussion about the AI-Ready Stack on the Tech Leaders Stage.
Planning to attend?
You can book a live demo for WeAreDevelopers or for AWS Summit in advance. We’d love to show you Dash0 in action.
Until next time - keep tracing, keep shipping, and maybe, just maybe, skip that extra debug log.
Kasper, out!
