OpenTelemetry on foojay.io - Friends of OpenJDK

Quarkus Unpacked: Insights from the Foojay Podcast

Tue, 23 Jun 2026 12:36:54 +0000

I recently had the pleasure of joining the Foojay podcast to talk about Quarkus in depth. The conversation covered a lot of ground, from what makes Quarkus different to the practical trade-offs between JVM and native mode. This post captures the key questions and answers from that discussion, lightly edited for readability.{#_quarkus_unpacked_insights_from_the_foojay_podcast}

If you have been following this blog series, note that the third installment on building your own stack with Quarkus is coming next. Consider this a bonus entry that distills the podcast conversation into a format you can read, reference, and share.

Observing Apache NetBeans with OpenTelemetry and Dash0

Sun, 14 Jun 2026 22:03:09 +0000

What happens when you point an observability agent at your IDE rather than your application?

The question nobody thinks to ask

Observability is something we do to our applications. We instrument services, add trace context to HTTP requests, collect JVM heap metrics, ship logs to a backend. The IDE we use to write that instrumentation is — by convention — invisible. It just runs. When it is slow, we assume it is busy. When it crashes, we restart it. We have no data.

From Zero (Really Zero) to OpenTelemetry

Tue, 19 May 2026 13:36:11 +0000

Here’s a super awesome prompt (e.g., for Claude Code) that you can use with https://github.com/dash0hq/agent-skills , the free collection of skills for AI coding agents to make applications observable with OpenTelemetry, such as with Dash0 .

And the end result is this, a view into the traces of your application (without anything at all at the start of the process).

The Super Awesome Prompt

Take a careful look below: before doing this prompt, not only do we not have an application that is instrumented with OpenTelemetry yet. Not only do we not have the agent we need to do the instrumentation yet.

From Zero to Full Observability with Dash0

Sat, 04 Apr 2026 06:35:47 +0000

This guide walks through the complete process of deploying a minimal Spring Boot service to Kubernetes and adding full observability using the Dash0 Kubernetes Operator — without making any changes to the application code.

Dash0 is an OpenTelemetry-native observability platform that collects and correlates traces, metrics, and logs, and provides infrastructure monitoring across Kubernetes resources — pods, nodes, namespaces, deployments, daemonsets, statefulsets, jobs, and cronjobs — as well as cloud infrastructure such as AWS. Its Kubernetes operator can automatically instrument workloads at the pod level, with no changes required to application code or container images.

Spring Boot 4 - OpenTelemetry Guide

Wed, 10 Dec 2025 09:09:58 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. In this second article, I will dive deep into integration of Observability framework i.e., OpenTelemetry with SpringBoot.

As an architect and developer, when I engage in system design—whether it involves monolithic architecture, microservices, or contemporary cloud-native applications—I have made the integration of observability patterns utilizing open-telemetry tools a standard practice. Through observability, we can monitor application behavior via metrics, logs, and traces that we trigger

OpenTelemetry Tracing on the JVM

Sun, 17 Aug 2025 08:00:39 +0000

You may know I’m a big fan of OpenTelemetry. I recently finished developing a master class for the YOW! conference at the end of the year. During development, I noticed massive differences in configuration and results across programming languages. Even worse, differences exist across frameworks inside the same programming language.

In this post, I want to compare the different zero-code OpenTelemetry approaches on the JVM, covering the most widespread:

Spring Boot with Micrometer Tracing
Spring Boot with the OpenTelemetry Agent
OpenTelemetry Spring Boot Starter
Quarkus
Quarkus with the OpenTelemetry Agent

Commonalities

I keep the architecture pretty simple:

Spring Cloud Stream for Real-Time Event-Driven Systems

Mon, 21 Jul 2025 13:33:34 +0000

Envision operating a successful e-commerce platform where every moment is crucial. Customers make purchases, adjust inventory levels, process payments, and dispatch shipping alerts—all in real time. In the background, microservices diligently function to guarantee seamless operations. However, how do these services interact effectively, particularly during peak traffic occurrences such as flash sales or holiday shopping events?

An efficient method to execute this use case involves utilizing Spring Cloud Stream (SCS) as the messaging infrastructure. SCS facilitates seamless interaction among microservices, enhancing the system’s responsiveness and scalability. A significant benefit of SCS is that it provides an abstraction layer, allowing developers to transition between messaging technologies such as Kafka or RabbitMQ or Pulsar or Amazon Kinesis without altering their fundamental business logic.

Challenge yourself with Application Observability Code Challenges

Wed, 22 Jan 2025 13:19:56 +0000

Code challenges are a nice way to challenge yourself with programming, resulting in some great challenges like #1brc and the yearly Advent of Code (#AoC) .

While these challenges often include a competitive element, the Application Observability Code Challenges are focussed on the learning about observability practices.

What are the Application Observability Code Challenges?

The idea of these challenges came to me based on the challenges above and the fact that I see in practice that quite a few developers are struggling to get up to speed with applying observability practices.

OpenTelemetry Tracing on Spring Boot, Java Agent vs. Micrometer Tracing

Thu, 22 Aug 2024 08:34:57 +0000

My demo of OpenTelemetry Tracing features two Spring Boot components. One uses the Java agent, and I noticed a different behavior when I recently upgraded it from v1.x to v2.x. In the other one, I’m using Micrometer Tracing because I compile to GraalVM native, and it can’t process Java agents.

I want to compare these three different ways in this post: Java agent v1, Java agent v2, and Micrometer Tracing.