A simple new way to visualize Prometheus

Even if you don’t work with Prometheus day-to-day, you most likely have heard of it. After Kubernetes was donated to the Cloud Native Computing Foundation (CNCF), Prometheus became the second project to be incubated soon after. That was back in 2016 and it is still one of the most active CNCF projects. Why is it so popular? It’s the de facto monitoring tool for containerized workloads running on-prem and in the cloud – that is, it’s the monitoring tool for Kubernetes. PromQL (the Prometheus Query Language) has become the standard for metric queries and Azure, AWS and GCP now all offer PromQL-compatible monitoring as part of their container platforms.

Put simply, Prometheus is huge.

It’s also a little complicated.

Our focus at SquaredUp has been to simplify it – to make it much easier to consume the data and get insights from people who might not be experts in PromQL, like developers, platform engineers, and managers. There are already a number of visualization options for Prometheus – Prometheus’s own web front-end, Perses (a new open-source project), and of course Grafana – but SquaredUp makes visualizing, monitoring, and sharing your Prometheus data easier than ever before.

Here’s what’s new:

• A radically simple new way to query Prometheus
• New out-of-the-box dashboards for Kubernetes
• Support for Prometheus 3.0
• Updated OpenTelemetry support

Let’s take a look at these features in action.

PromQL-free queries

PromQL is the Prometheus query language. It's used to populate dashboards with metrics and to configure alerts for certain conditions.

Here’s an example of a PromQL query for the 95th percentile response time of the 'cart' service:

histogram_quantile ( 0.95, rate ( http_server_request_duration_seconds_bucket { "service_name"="cart" } [ 1h ] ) )

If you have written a PromQL query, you’re probably familiar with the many tutorials and cheat sheets out there on the web. While the basic syntax is straightforward, there are some extremely tricky concepts that you need to get your head around:

• Gauge vs counter vs summary vs histogram
• Whether to run an instant or range query
• How to combine _total, _sum and _histogram series
• When to use which aggregations and in what order to apply the aggregations

If you know what you’re doing, you can paste regular PromQL straight into your SquaredUp dashboard configuration. But we wanted to make querying Prometheus more accessible for those less familiar with PromQL, or just a whole lot easier and quicker for those that do! So, as an alternative to PromQL, SquaredUp offers a ‘Simple Query’ option. Under the covers, it builds PromQL for you, but offers a simple, intuitive, guided way to get the data you want to see.

Here’s a short video that builds the same P95 duration query above, but without any PromQL:

Combined with SquaredUp’s intuitive visualization options, it makes going from idea to visualization a breeze.

The Simple Query option makes building custom visualizations easy, but starting from a blank page can be daunting. Where do you start?

Out-of-the-box Kubernetes dashboards and drilldowns

Our new Prometheus integration comes bundled with ready-made dashboards that instantly give you insights into your Prometheus and Kubernetes environment, and also act as a starting point for your own custom dashboards.

Part of the magic of SquaredUp dashboards, and what makes them smarter than conventional dashboards is that they ‘understand’ the data they’re showing. This means you can drill into the objects shown on the top-level summary dashboards to get to more detail, and seamlessly navigate between different contexts and levels of detail.

Using the Kubernetes dashboards as an example, this means you get a high-level cluster summary telling you about important issues, with intuitive drilldowns into a node, and from there into a pod running on the node. When we drill down, we’re not just applying a filter to the dashboard, we’re viewing a dynamic new page that is contextual to the pod object – we’re actually viewing the pod. This is a highly intuitive way of reasoning about your observability data and finding answers.

Here’s a short sequence of screenshots exploring a Kubernetes environment running the OpenTelemetry Telescope Shop demo application.

The Kubernetes cluster overview, identifying key performance metrics and pod restarts:

Drilling down into a host, we can see the pods running and their key metrics:

And finally into a pod, to troubleshoot resource usage and restarts:

Using labels for context and correlation

Prometheus data can feel like a maze of metric names and labels, with the useful insights hidden somewhere inside. To make the data more intuitive to work with, SquaredUp indexes key labels and imports them as objects into our knowledge graph. This is how we provide contextual views on top of your Kubernetes nodes and pods, and the services they are hosting.

We provide support for both conventional Kubernetes labels such as pod and node, as well as OpenTelemetry Semantic Conventions such as k8s.pod.name and node.name (Side note: we’ve added support for Prometheus 3.0 so you can now use underscores or dots!)

Here’s what SquaredUp finds when we plugin into a Prometheus instance running on the OpenTelemetry Telescope Shop demo application:

You can see the pods running the Telescope Shop, such as the cart and ad service. Remember, SquaredUp isn’t ingesting any of the metric data – that all lives in Prometheus – but it does use the labels to infer what objects the Prometheus instance is monitoring. This powers both the Simple Query described earlier and the drilldowns, makes dashboarding and browsing your data much easier.

It also means you can correlate it with data from any other tool. You might have spotted in the video above that the drilldowns showed tabs for other tools such as OpenSearch and AWS CloudWatch. What’s going on there?

We’re going to save the details for another blog, but by indexing objects in each of the tools SquaredUp connects to, it can correlate data across tools – in this case logs from OpenSearch and EC2 metrics and status from AWS CloudWatch This isn’t just a convenience feature to reduce the number of open tabs, it creates an intuitive way to find insights without being an expert in each of the observability tools in your environment.

Check it out – for free

The new Prometheus integration is a powerful – and really simple – way to visualize and monitor your Prometheus data. Alongside the other 60 or so integrations available, it extends the reach of SquaredUp’s single pane of glass visibility into the Kubernetes ecosystem.

Best of all, you can check out our Prometheus integration completely for free and takes a few minutes to get up and running, just sign up here.

Go ahead and check it out – as always, we’d love to hear your feedback.