Operations | Monitoring | ITSM | DevOps | Cloud

Traceparent: How OpenTelemetry Connects Your Microservices

In a microservices setup, tracking a single request across services quickly gets complex. One service calls another, then a third, and your logs don’t line up. The traceparent header carries context between services, so all parts of a request connect back to the start. For example, when a frontend sends a request to an API, which then calls a database service, traceparent it links those calls in the trace. Without it, you’re left guessing how requests flow.

Shedding Light on Kafka's Black Box Problem (with OpenTelemetry)

"All language is but a poor translation." — Franz Kafka This quote by Franz Kafka reminds me of the time when I used to look at metrics from “Apache Kafka” topics trying to figure out what was causing the huge lags and manually deleting the messages in certain partitions to get rid of polluted messages. Yep, pretty lost in translation. I wasn’t aware of the power of observability for a Kafka producer-topic-consumer system.

Easy Way to Convert Wavefront Metrics Using OpenTelemetry

Once upon a time in the world of metrics, Wavefront was a pioneer. Before Prometheus took over and tools like OpenTelemetry unified tracing and metrics, Wavefront brought something novel to the table: human-readable metrics with real-time querying and tag-based dimensionality. In enterprise environments running VMware or early microservices, it offered a scalable way to understand a system's behavior. But as the telemetry landscape evolved, many systems that spoke Wavefront were left behind.

Using the OpenTelemetry Operator to boost your observability

If you’ve ever wrangled sidecars or sprinkled instrumentation code just to get basic trace data, you know the setup overhead isn’t always worth the payoff. But what if it was… just easier? That’s where the OpenTelemetry Operator for Kubernetes steps in… and it plays great with Coralogix out of the box!

OpenTelemetry vs Micrometer: Here's How to Decide

In a distributed system, things break in unexpected ways. That’s why observability isn’t optional—it’s how you understand what’s going on under the hood. If you’re comparing tools to instrument your services, OpenTelemetry and Micrometer are two names you’ll run into. Both are used to collect metrics, but they take very different approaches—especially when it comes to flexibility, vendor support, and what you can do with the data.

Set Up Tracing for a Ruby on Rails Application in AppSignal

In this guide, we'll harness AppSignal to detect, diagnose, and remove performance bottlenecks and employ proper tracing in a Ruby on Rails application. From setting up tracing to capturing errors and logging, we’ve got you covered. We'll ensure our application runs smoother than ever, even under the heaviest loads! But first, let's quickly touch on how to define tracing and its benefits.

OpenTelemetry with Prometheus: better integration through resource attribute promotion

With the 3.0 release, Prometheus firmly established itself as the leading metrics database for OpenTelemetry. A lot of work has gone into integrating the two open source projects, including a major Prometheus enhancement we’re really excited about: resource attribute promotion.

Grafana Tempo vs Jaeger: Key Features, Differences, and When to Use Each

Both Grafana Tempo and Jaeger are distributed tracing tools designed for modern microservice architectures. Jaeger, released as an open-source project by Uber in 2015, has matured into a graduated CNCF project. Tempo, announced by Grafana Labs in October 2020, is a newer entrant focused on high-volume tracing with a unique storage architecture. Before comparing these tools in detail, let's quickly review what distributed tracing is and why it matters.

Learning from LFX Mentorship @ CNCF - Jaeger

Hariom Gupta Follow 4 min read· 1 hour ago -- Listen Share Starting this journey was both exciting and fulfilling — and now, here I am at the finish line, having successfully completed the LFX Mentorship Program and reflecting on the experience through this blog. The past three months have been incredible — surpassing my expectations in so many ways.

Tracing Funnels - Define funnels between spans | SigNoz Launch Week 4.0 Day 5

Build funnels directly on your traces and get instant answers to questions like: What fraction of spans made it from event A to event B? Between which spans are most requests failing? What is the latency between key spans? Traditional observability tools let you inspect traces and spans, but they can’t aggregate or analyze how requests flow across multiple services or stages in your system. In asynchronous, distributed architectures, the root span rarely tells the full story-and there’s no way to measure conversion, drop-off, or latency between arbitrary steps across all traces.

A Mindset Shift: Making Observability Integral to DevOps Practices: Datev & OpenTelemetry | Grafana

In the evolving landscape of DevOps, observability is no longer optional—it’s a fundamental pillar of success. During this session, Gunter from Datev explores the critical mindset shift required to make observability an integral part of DevOps practices.

Tracing Funnels - Define funnels b/w spans in your distributed systems

Distributed tracing has long been the go-to for understanding the performance of microservices and asynchronous systems. But as systems grow in complexity, simply viewing individual traces and spans isn’t enough. Teams need to answer questions like: SigNoz Tracing Funnels is here to change that, bringing the clarity of product analytics-style funnel analysis to backend traces, and doing so in a way that’s never been available before.

CI/CD Observability Powered by OpenTelemetry

Modern engineering teams spend a lot of time and resources in setting up monitoring of their production systems - tracking uptime, catching errors, and responding to incidents before customers ever notice. But what about the journey before code reaches production? For most teams, observing the CI/CD pipeline is either an afterthought or completely overlooked. While we recognize its importance, do we truly understand how well our CI/CD process is functioning?

CI/CD Observability Powered by OpenTelemetry | SigNoz Launch Week 4.0 Day 4

Tired of guessing why your releases stall, which PRs are stuck, or where flaky tests are wasting your team’s time? Most teams obsess over production monitoring, but what about the bottlenecks that often hide in the CI/CD pipeline slowing delivery, draining productivity, and introducing risk before code ever ships. With CI/CD Observability, you can: So, stop flying blind in your delivery process and make every release faster, more reliable, and fully transparent!

Third party API Monitoring Powered by OTel Semantic Conventions | SigNoz Launch Week 4.0 Day 3

Is it the third-party API or my code? Your service suddenly slows down, or errors spike, and you’re stuck guessing if it’s your own logic or an external API you don’t control. We’ve seen this pain across teams: dashboards don’t tell you which vendor or endpoint is the culprit, and debugging turns into a maze of guesswork. Rate limiting, vendor errors, or integration issues often slip through until users complain.

Introducing Metrics Explorer | SigNoz Launch Week 4.0 Day 2

Ever tried to build a metrics dashboard and thought, “Wait, what metrics am I actually sending?” We heard this from users again and again-so we built Metrics Explorer. For the first time, you get a real-time, interactive view of every metric coming into your system: Whether you’re onboarding a new integration, debugging an alert, or just exploring your data, Metrics Explorer makes it easy to understand and work with your metrics-no more guesswork, just clarity.

CI/CD Observability Powered by OpenTelemetry and SigNoz

Most teams have strong monitoring for production, but what about the journey before your code gets deployed? The CI/CD pipeline is where bottlenecks, flaky tests, and process gaps silently waste your team’s time. Until now, this part of the workflow has mostly been a black box. We’re excited to announce CI/CD Observability in SigNoz - a new way to track, analyze, and improve your software delivery process, powered by OpenTelemetry.

Tracing Funnels - Define funnels b/w spans in your distributed system

Build funnels directly on your traces and get instant answers to questions like: What fraction of spans made it from event A to event B? Between which spans are most requests failing? What is the latency between key spans? Traditional observability tools let you inspect traces and spans, but they can’t aggregate or analyze how requests flow across multiple services or stages in your system. In asynchronous, distributed architectures, the root span rarely tells the full story-and there’s no way to measure conversion, drop-off, or latency between arbitrary steps across all traces.

Third party API Monitoring powered by OpenTelemetry semantics

In today’s cloud-native world, third-party APIs are everywhere. Payments, notifications, search, AI, analytics as modern applications are built on a web of external services. But what happens when one of those APIs slows down, starts throwing errors, or gets rate-limited? Suddenly, your users are facing issues, and you’re stuck asking.

Tracing Just Got a Whole Lot More Useful: Search, Visualize, and Alert with Sentry's new Query Engine

For a while, tracing in Sentry was... fine. You could open up a slow transaction, poke around, find the N+1, and feel like a hero. But if you wanted to answer more complex questions - like why your payment API was getting slower in Europe, or which CDN was silently tanking your image loads - things got harder. We didn't really build it to help with answering broad questions.

Deep Temporal Observability | SigNoz Launch Week 4.0 Day 1

If Temporal powers your business-critical workflows, you know how tough it is to get real visibility into what’s happening under the hood. Most tools only show basic Prometheus metrics-leaving you guessing about bottlenecks, failures, and performance issues. Join us for a live demo of SigNoz’s industry-first Temporal integration. We’ll show you how to: Whether you’re running Temporal in production or just exploring workflow orchestration, this session will show you how to move from “just metrics” to true, unified observability.

Unifying OpenTelemetry & Datadog | #Observability #OpenTelemetry #datadog

Previously, teams had to choose between adopting the OpenTelemetry Collector’s capabilities and fully leveraging our advanced features. On This Month in Datadog, we’re spotlighting our OTel Collector distribution, which unifies OTel and Datadog. Check out the link in our bio to watch the new episode.

Angular OpenTelemetry Setup and Troubleshooting

Implementing observability in Angular applications presents unique challenges. Understanding how users experience your application and identifying performance bottlenecks requires specialized tools and approaches. This guide covers implementing OpenTelemetry in Angular applications, with practical code examples for instrumentation, data collection, and integration with observability backends.

Metrics Explorer - Search, Query, and Analyze all your Metrics at one place

Ever tried to build a metrics dashboard and thought, “Wait, what metrics am I actually sending?” We heard this from users again and again-so we built Metrics Explorer. For the first time, you get a real-time, interactive view of every metric coming into your system: Whether you’re onboarding a new integration, debugging an alert, or just exploring your data, Metrics Explorer makes it easy to understand and work with your metrics-no more guesswork, just clarity.

This Month in Datadog: OpenTelemetry Collector distribution, GitHub Copilot integration, and more

Datadog is constantly elevating the approach to cloud monitoring and security. This Month in Datadog updates you on our newest product features, announcements, resources, and events. To learn more about Datadog and start a free 14-day trial, visit Cloud Monitoring as a Service | Datadog. This month, we put the Spotlight on the Datadog Distribution of the OpenTelemetry Collector.

CloudWatch vs OpenTelemetry: Choosing What Fits Your Stack

Choosing the right observability setup isn’t just a checkbox—it affects how quickly you can detect issues, debug them, and keep your systems reliable. CloudWatch and OpenTelemetry take different paths to that goal: one is a managed service tightly coupled with AWS, the other a flexible, open-source framework that's becoming a go-to in modern monitoring stacks.

Third party API Monitoring Powered by OpenTelemetry Semantics

Is it the third-party API or my code? Your service suddenly slows down, or errors spike, and you’re stuck guessing if it’s your own logic or an external API you don’t control. We’ve seen this pain across teams: dashboards don’t tell you which vendor or endpoint is the culprit, and debugging turns into a maze of guesswork. Rate limiting, vendor errors, or integration issues often slip through until users complain.

OpenTelemetry PHP: A Detailed Implementation Guide

Monitoring complex PHP applications can be challenging. When systems span multiple services and environments, traditional logging approaches often fall short. OpenTelemetry offers a solution - an open-source, vendor-neutral framework that standardizes how we collect and export telemetry data. This guide covers practical implementation steps for DevOps engineers working with PHP applications.

Grafana Alloy at 1: What's new and what's next for our OpenTelemetry Collector distribution

It’s been a year since we launched Grafana Alloy, our OpenTelemetry Collector distribution with built-in Prometheus pipelines and support for metrics, logs, traces, and profiles. OpenTelemetry is quickly becoming an industry standard for telemetry collection, processing, and delivery, and we’re committed to making Alloy the best possible collector for telemetry data, whether you’re using it with Grafana Cloud or not.

Optimising OpenTelemetry Pipelines to Cut Observability Costs and Data Noise

Fat bills from observability vendors and tons of not-so-insightful telemetry data have turned out to be a very common issue today. This often leaves teams having to explain the lack of clear ROI, despite the growing costs. If you’re using OpenTelemetry to record your observability data, there are some practical methods you can apply to keep those costs from piling up.

The Definitive Guide to OpenTelemetry Exporters for High-Performance Monitoring

In modern distributed architectures, observability has shifted from optional to necessary. OpenTelemetry has emerged as the standard framework for telemetry data collection, with exporters serving as the critical bridge to your backend monitoring systems. For developers at any stage—those new to observability practices or those refining existing monitoring setups—a solid grasp of OpenTelemetry exporters will significantly reduce debugging time and improve system visibility.

Reporting CSP Errors in Honeycomb With the OpenTelemetry Collector

The HTTP Content-Security-Policy response header is used to control how the browser is allowed to load various content types. It is used to control which URLs, fonts, images, scripts, and more can be loaded onto the page. It’s a great defense against XSS (cross-site scripting), clickjacking, and cross-site vulnerabilities. The header can also specify a URL that will be used to send reports on violations of these properties.