Operations | Monitoring | ITSM | DevOps | Cloud

Today, many DevOps and security teams operate in a world of complex, hybrid, or multi-vendor environments. As more teams look to avoid lock-in by adopting open standards, OpenTelemetry (OTel) is quickly gaining adoption as the primary open source method for DevOps and security teams to instrument and aggregate their telemetry data. However, OTel alone may lack the advanced processing functions, native volume control rules, and hybrid environment support that large organizations need.

OpenTelemetry now supports maps, heterogeneous arrays, and byte arrays across all signals. Here’s where these new types shine — and where simple primitives still fit naturally. If you’ve been working with OpenTelemetry for a while, you’re likely familiar with the straightforward key-value approach to attributes. It’s simple, fast, and works well with how most telemetry backends store, index, and query data.

Distributed tracing tracks how a single request moves across multiple microservices, helping teams see the entire execution path end to end. In modern architectures where dozens of services interact, it becomes difficult to understand where latency starts, why bottlenecks appear, and which component breaks under load. Traditional monitoring only shows isolated metrics. Distributed tracing connects those dots.

Dashboards and alerts can tell you something’s wrong, but they don’t immediately tell you why. A red indicator or synthetic test failure prompts detective work. You flip between dashboards, timestamps, and logs, trying to line up what the check saw with what the system did. Now imagine your monitoring could explain itself by sending traces directly into your OpenTelemetry (OTel) backend.

The OpenTelemetry Java Agent provides zero-code instrumentation for Spring Boot applications through bytecode manipulation. This guide covers setup, configuration, auto-instrumentation capabilities, and production deployment strategies for implementing distributed tracing and observability.

Observability has become one of the fundamental elements of performance and reliability as modern applications move toward cloud-native architectures, microservices, and multi-cloud. Traditional monitoring techniques often fall short in such dynamic, distributed environments. That’s where OpenTelemetry (OTel) , an open-source observability framework comes into picture.

Some parts of a system don’t lend themselves to quick instrumentation changes. You might have a production binary that hasn’t been rebuilt in years, or a stack made of several languages where each team manages telemetry differently. In those situations, getting consistent signals often means touching code you’d rather leave alone or coordinating updates across many services. OpenTelemetry eBPF Instrumentation (OBI) approaches this from the kernel side.

When you run services on Quarkus, you need a steady stream of signals to understand how the application behaves—CPU trends, request timings, memory patterns, and how each endpoint responds under load. Metrics give you that visibility. They help answer questions like: OpenTelemetry fits well here because it gives Quarkus a common way to generate and export metrics without locking you into a specific monitoring tool.

Splunk is very excited to be sponsoring Kubecon North America once again, kicking off this week in Atlanta, GA. As many know, Splunk is one of the top contributors to the OpenTelemetry project. We’re happy to have sent many of the Splunkers who serve as project maintainers and contributors to lead SIG meetings and engage with the greater community in the OpenTelemetry Observatory, sponsored by Splunk.