Operations | Monitoring | ITSM | DevOps | Cloud

Traces & Spans: Observability Basics You Should Know

In modern software architecture, applications aren't just getting bigger—they're getting more distributed. With microservices, serverless functions, and containers running across multiple environments, understanding what's happening inside your systems can feel like trying to track a single raindrop in a storm. That's where traces and spans come in. These observability tools aren't just buzzwords—they're your secret weapon for making sense of complex distributed systems.

How to get started with frontend observability: A quick Grafana Faro example

Modern cloud-native applications and web browsers are highly complex, making it challenging to gain visibility into their performance. Without an effective way to track and measure frontend performance, it becomes difficult to monitor real user experiences, detect critical issues, assess website health, and ensure optimal functionality. But what if you could see exactly what your users are experiencing in real time?

New Feature: Manage Your session.id in Honeycomb's Web SDK

The session.id field is special in Honeycomb for Frontend Observability. It’s a default option for filtering and grouping, and it’s the basis for session timeline analysis (in Early Access). Now you can control how session.id is set. In prior releases (< 0.15.0) of the Honeycomb Web SDK, we used our own UUID generator for session.id, and it was not accessible outside of the Web SDK itself. As of version 0.15.0, we give you full control.

Troubleshooting Java Applications with Coroot

Java applications run on top of the JVM — a powerful but complex runtime environment that re-implements many OS features. It has its own memory management, garbage collector, and dynamic code compiler (JIT). While these features help with performance and portability, they often make troubleshooting a real challenge. At Coroot, we recently improved our support for continuous profiling in JVM-based applications.

Data Strategy for SREs and Observability Teams

In Honeycomb’s Customer Architects team, we work with the full spectrum of team, scope, and budget sizes. “The data isn’t valuable enough” is something we’re always dismayed to hear, but we hear it often enough. The thing is, as much as we want it to not be true, no product or tool can magically maximize the value of your telemetry data—at least not without gobs of human input, oversight, and review.

The Power of Over 3000 Intelligent Observability Agents

Catchpoint has officially crossed a major milestone: over 3,000 intelligent agents now power our Global Agent Network. This isn’t just a big number. It underscores our commitment to helping our users monitor what matters, from where it matters most: the end user. With agents deployed across 105 countries, 346 cities, and every layer of the Internet stack, Catchpoint now offers the broadest and deepest visibility into user experience available today.

Team-Oriented Observability with Coroot

Modern apps are built by many teams, each owning a different set of services: APIs, background jobs, databases, platform components, and more. As the system grows, it gets harder for each team to focus on what actually matters to them.When everything is mixed together, dashboards get messy, service maps are too large to be useful, and alerts end up reaching the wrong people. Instead of helping, your observability stack turns into a distraction. It has lots of data, but no clear context.

Advanced Python Logging: Mastering Configuration & Best Practices for Production

Python's logging system provides powerful tools for application monitoring, debugging, and maintenance. This comprehensive guide covers everything from basic setup to advanced implementation strategies, helping you build robust logging solutions for your Python applications.

AI Agent Observability Explained: Key Concepts and Standards

AI agent observability has become a critical discipline for organizations deploying autonomous AI systems at scale. This guide explores the emerging standards and best practices for monitoring, analyzing, and improving AI agent performance in enterprise environments.

How Much Should I Be Spending On Observability?

In 2018, I dashed off a punchy little blog post in which I observed that teams with good observability seemed to spend around ~20-30% of their infra bill to get it. I also noted this was based on absolutely no data, only my own experiences and a bunch of anecdotes, heavily weighted towards startups and the mid-market tech sector. This post should have ridden off into the sunset years ago. To my horror, I have seen it referenced more in the past year than in all preceding years combined.