Systems run into problems all the time. To keep things running smoothly, we need to have an error monitoring and logging system to help us discover and resolve whatever issue that may arise as soon as possible. The bigger the system the more challenging it becomes to monitor it and pinpoint the issue. And with serverless systems with 100s of services running concurrently, monitoring and troubleshooting are even more challenging tasks.

Over the years, we’ve heard many versions of the same familiar story: large businesses struggling with observability data living in several different systems. At Grafana Labs, our “big tent” philosophy is based on the belief that our users should determine their own observability strategy and choose their own tools. Grafana allows them to bring together and understand all their data, no matter where it lives.

In the first post of this series, we covered the general idea and benefits of model-driven observability with Juju. In the second post, we dived into the Juju topology and its benefits with respect to entity stability and metrics continuity. In this post, we discuss how the Juju topology enables grouping and management of alerts, helps prevent alert storms, and how that relates with SRE practices.

As I said before, Speed is King. Business requirements for applications and architecture change all the time, driven by changes in customer needs, competition, and innovation and this only seems to be accelerating. Application developers must not be the blocker to business. We need business changes at the speed of life, not at the speed of software development.

As developers, we spend a lot of time in our IDEs writing new code, refactoring code, adding tests, fixing bugs and more. And in recent years, IDEs have become powerful tools, helping us developers with anything from interacting with HTTP requests to generally boosting our productivity. So you have to ask — what if we could also prevent security issues in our code before we ship it?

Register for the webinar and download the full study to see and apply Forrester’s financial model to determine the observability ROI for your organization. Many teams want to adopt observability and Honeycomb—but run into budget roadblocks because budget holders may not clearly understand the quantifiable benefits to their end users, their teams, and the bottom line.

A fundamental element of the Kubernetes microservices system is the services model, which gives teams greater understanding of how their applications are deployed. These objects running within pods and containers, by extension, are RESTful since they’re based on APIs. However, DevOps teams can’t hope to run a tight ship without managing their services. Communication and visibility are absolutely crucial in a Kubernetes system.

In the first post of this series, we covered the general idea and benefits of model-driven observability with Juju, but did not dive deep into the idea of contextualization and how it makes observability more actionable. In this post we start addressing what contextualization means in model-driven observability, starting from adding Juju topology metadata added to telemetry, and how that improves the processing and querying the telemetry for charmed applications.

Companies are always looking for transparency and visibility when it comes to monitoring, but as monitoring requirements and methods evolve, it’s not always easy to keep up. That’s why Opsdis, an observability consulting company based in Göteborg, Sweden, was founded. The firm focuses solely on helping clients implement systems for monitoring and metrics so they can keep up with the ever-expanding world of cloud computing and containerized environments.

Digital transformations can entail significant shifts in technology, such as migrating from on-site architecture to cloud services, and these complex transformations generate massive amounts of data. Data transparency is a must-have, and observability with AIOps delivers the solution. Through a unified view of data, AIOps guides DevOps and SRE teams through the swamp of information

An application running in production is a difficult beast to tame. Most experienced developers–ones who spent enough late nights or Saturday mornings trying to break apart a nasty production bug–will try and create the clearest possible picture for their later selves while writing their code, so that they could understand what’s actually going on in the system during an incident.

OpenTelemetry (or “OTel”) helps you get your instrumentation started quickly, and it helps you get the most out of that telemetry data by providing flexible exporting options. As a result, it’s emerging as the new standard for instrumentation. To that end, today we’re sharing more insight into the work we’ve done (and are doing) to enable a path for all Honeycomb users toward OTel adoption. We hope you’ll be as excited as we are to embrace these open standards!

Today you likely have one or more legacy APM (Application Performance Monitoring) solutions. You are moving from a monolithic architecture to microservices, and you are accelerating your journey to Cloud, and you need to deliver at speed with scale and quality to your customers. Sadly, visibility into these results are limited to each of these solutions and their interfaces.

You’re likely familiar with local debugging—the ability to go through your code line by line to find and eliminate bugs. However, with the ever-increasing complexity of development environments, working efficiently with remote systems is becoming more necessary. In this case, “remote” can mean any machine you don’t have native OS-level access to, such as Virtual Machines, Docker containers, and entirely separate devices accessed over the network.

“Observability,” is the process in DataOps of recording data generated by digital systems as they go about their processes. There are some great companies in the observability space, generating a whopping $17 billion annually, and contributing a significant portion to the modest 2.5 quintillion bytes of data created every year.

Keeping the experience of your end user in mind is important when developing applications. Observability tools help your team measure important performance indicators that are important to your users, like uptime. It’s generally a good practice to measure your service internally via metrics and logs which can give you indications of uptime, but an external signal is very useful as well, wherever feasible.

Honeycomb is known for its incredibly fast performance: you can sift through billions of rows, comparing high-cardinality data across thousands of fields, and get fast answers to your queries. And none of that is possible without our purpose-built distributed column store. This post is an introduction to what a distributed column store is, how it functions, and why a distributed column store is a fundamental requirement for achieving observability.

In modern software systems, it is common for several developers to work on the same project simultaneously. Siloed working with infrequent merging of code in a shared repository often leads to bugs and conflicts that are difficult and time-consuming to resolve. To solve this problem, we can adopt continuous integration.

Every now and then, issues occur that disrupt the very fabric of global software engineering. Chief amongst them is the recent mass outage of Github. Github is a fundamental building block in software productivity, hosting over 190 million code repositories. Github hosts our code and libraries, runs build pipelines, and much more. It is a central hub of activity and it is consumed by tens of thousands of organizations.

The content delivery network (CDN) has been an integral part of application infrastructure for more than two decades. A CDN is critical to the end-user experience, but it is no longer considered to be just a caching server. It has evolved to provide security from cyber threats, including DDOS attacks along with front end optimization. Although CDN services are now an indispensable part of any application infrastructure, visibility into CDN performance remains limited.

A selection of questions and answers from our recent webinar on leveraging AIOps to run sustainable, blameless retrospectives.

Is GitOps changing observability as we know it? GitOps has been the buzz word in the DevOps space for several years. GitOps, to those that are not familiar, is an operational methodology for DevOps that leverages a continuous deployment approach with Git as the single source of ‘truth’ for declarative control over both infrastructure and applications.

After building Lightrun for the JVM – an easier way to get a better grasp on production applications written in Java, Scala, and Kotlin – we’re pleased to announce the release of Lightrun’s developer-native observability platform for Python!

Your feedback is what makes Honeycomb better. We ship changes often (you can see updates in real time on our changelog), so it can be easy to miss some of the new improvements that can help you get the most out of Honeycomb. Whether it’s a big new product feature or an enhancement of existing features, you may not always be up on the latest goodness waiting for you in Honeycomb.

Observability is a hot term in the industry, but don’t let it fool you: having visibility into your organization's apps and services only gives you partial clarity into a system’s overall performance. To get a full understanding of your monitoring data, you need to apply contextual intelligence.

Do you also find yourself confused by all the Open-this and Open-that names flying around? There are currently a good few Open projects, standards, tools – OpenTelemetry, OpenTracing, OpenCensus, OpenSearch… heck, even my podcast is called OpenObservability! And new Open names seem to be popping up every other day. If you too feel this way, there’s no need. Many feel similarly confused.

We’re pleased to share that Circonus saw record sales for the quarter ending June 30, 2021 and substantial year-over-year growth in annual recurring revenue (ARR). We’re experiencing significant momentum in 2021 as more organizations look to consolidate monitoring solutions, unify observability metrics across the stack, and manage a significantly greater volume of telemetry data.

The end-to-end monitoring of complex software systems is difficult, toil-intensive and error-prone. Developers, SREs and Platform teams must continuously invest effort in setting up and maintaining the monitoring setups that underpin the observability of their systems, or accept the risk of being unaware of ongoing issues and their impact on end users. Enter model-driven observability powered by Juju!