Changelog

Built on the foundation of the dash0.spansCopy metric, dash0.span.eventsCopy empowers you to query the number of events associated with your spans. Its advanced filtering and grouping capabilities give you full access to span and event attributes, such as event names (otel.span.event.nameCopy), offering a new level of insight into your trace data via PromQL.

Analyze the occurrences of specific span events over time using the otel.span.event.name attribute

This metric is also at the heart of the all-new Dash0 Cost Estimate dashboard, now available in the Integration Hub. By breaking down event volumes across services, the dashboard provides a clear view of how your event data contributes to overall observability costs. With this knowledge, you can make smarter, data-driven decisions to manage and optimize expenses while maintaining visibility.

Dash0's Total Span Events by Service Panel from the Cost Estimate Dashboard

Start exploring dash0.span.eventsCopy today and experience a more detailed, actionable view of your trace data — helping you control costs.

As part of this update, our two thresholds annotations have been renamed to better align with other Dash0-specific extensions:

• threshold-degraded -> dash0-threshold-degraded
• threshold-critical -> dash0-threshold-critical

Additionally, we've reimagined our handling of the severityCopy label, offering you the freedom to assign any custom value that fits your needs.

These updates reflect our commitment to providing a seamless and intuitive experience for users adopting the Dash0 operator. For new users, we recommend adopting these updated naming conventions as detailed in our documentation. Existing users managing Dash0 Check Rules with the Prometheus alert rule format can rest easy—if a migration becomes necessary, we'll reach out to provide step-by-step guidance, ensuring a seamless transition.

With the Dash0 operator, managing check rules is simpler, more powerful, and tailored to your environment.

You can learn setup instructions through the Integrations Hub that help you get started quickly with AWS, Vercel, Node.js, and much more. It even comes with ready-made dashboards that model everyday observability needs, e.g., for the OpenTelemetry collector, Vercel, GitHub Actions, and more. We plan to extend it in the future with content about alerting and more. Check it out!

With this feature, Dash0 alerting notifications can be configured to route into Alertmanager for handling alerts, leveraging its existing mechanisms for routing, deduplication, and grouping. This provides an opportunity to integrate Dash0’s alerting with workflows already built around Prometheus and its related tools, without disrupting your current setup.

This notification channel is available in Beta and joins our recently added incident.io and BetterStack integrations. Together, these features reflect our ongoing commitment to giving you more options to align Dash0 with your existing observability workflows, whether they’re centralized within Dash0, or involve other tools in your ecosystem.

We’re excited for you to try this feature and explore how Dash0 can fit seamlessly into your alerting strategy.

When looking at a chart, you really don't want to present information about errors in a neutral (or even positive) color tone. Instead, you will want the color to signal that something is off by making it red or yellow. This now works by default within Dash0!

Dash0's semantic coloring system (see our article "Why is this red?") now works for custom charts, too!

Dash0's charting system automatically colorizing HTTP status codes and logs within a dashboard visualizing Vercel log drain information.

How does it work? When a time series is labeled with an attribute containing status-like information, such as log severities, span status codes, HTTP & gRPC status codes, etc., the charts automatically pick the right colors!

Learn more within our documentation on panel options.

The Dash0 operator is an open-source Kubernetes operator built on OpenTelemetry, Prometheus, Perses and other open-source projects, that provides you with an appliance-like way (one command, and all works!) of monitoring your Kubernetes clusters and the applications running on top of it.

Today we release the 0.37.0 version of the Dash0 operator, which automatically installs and configures the OpenTelemetry Java agent in your Kubernetes pods to monitor your Java applications out of the box.

Try it out and let us know what you think of it!

Dash0’s Vercel integration will automatically send all logs from your Vercel workloads to Dash0 for analysis and visualization. Instead of configuring a log drain in Vercel manually, you can just install the integration at https://vercel.com/integrations/dash0 and we do it all for you.

When the integration has been installed, logs from your Vercel projects will be sent automatically to Dash0. This is great news as the log retention within Vercel is only 3 days, while Dash0 offers 30 days of retention for logs and traces. You will also be able to analyze your Vercel logs in context with telemetry from your non-Vercel infrastructure, which makes troubleshooting so much easier.

Additionally, we have integrated the extraction of hostCopy and processCopy data from these logs, which is also aligned with OpenTelemetry standards. This improvement significantly enhances your ability to analyze and interpret Journald log data effectively.

OpenTelemetry journald receiver, https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/journaldreceiver

Having good resource attributes on your telemetry is paramount to understanding what is going on in your workloads. Logs, metrics and traces without resource information are basically just data without context. And yet, making sure there are correct Kubernetes resource attributes on all your telemetry is not always easy.

That v0.36 of the Dash0 operator now automatically adds k8s.namespace.nameCopy, k8s.pod.nameCopy, k8s.pod.uidCopy, and k8s.container.nameCopy to all workloads via the Dash0 injector. Under the hood, these attributes are added to the resource attributes sent by your applications via the OTEL_RESOURCE_ATTRIBUTESCopy environment variable. If the workload uses an OpenTelemetry SDK, this environment variable is automatically picked up, and the attributes defined in it are sent along with all the spans, metrics and log records that the application emits.

What's more, the Kubernetes Attributes Processor (which is deployed automatically by the Dash0 operator) will enrich telemetry with a host of other Kubernetes related resource attributes, like the Kubernetes namespace identifier, deployment name and unique identifier, replicaset name and unique identifier etc.

One less thing to worry about, one more thing that just works with Dash0.

Big news: Your workflow, your rules! 🎉 Personalize Dash0 like never before and keep your most-used views just a click away. Dive in and make it yours!

A common problem when creating a dashboard is forgetting to save. Painfully crafted queries and panels are lost. It's so annoying when that happens! No more with Dash0, though!

We even synchronize state across browser tabs for all those tab hoarders! 👀

The Dash0 dashboarding area indicates through a tag that there are unsaved modifications.

Some of our users wished to resize the sidebar to allow them to look at a chart with more space. You can now do this. Just drag the edge of the sidebar to where you want it to be!

Logs without a severity aren't nearly as actionable as those stating ERROR or WARN. Explicitly mapping these log levels can be challenging and commonly requires the painful definition of regular expressions.

This capability is currently in closed beta while we validate its effectiveness. Reach out to us to join this closed beta!

Dash0 automatically enriched most logs with unknown severity (in grey) with severity information (colored). Going from noise to signal in seconds!

Views in a nutshell help you to:

• quickly find a starting point for your search
• learn more about Dash0’s powerful filtering capabilities
• save time by focusing instantly on relevant data
• explore and understand complex datasets

Spoiler alert: We’re just getting started! Coming soon: The ability to create and save your own custom views, tailoring Dash0 perfectly to your unique datasets and workflows. Stay tuned for even more ways to make your data work for you!

Wherever you see a PromQL query, you can now click the small 🎓-button to learn more about the query. Dash0 will then…

• format the PromQL query to visualize its hierarchy,
• list the referenced metrics, including a quick reference of its type and availability and
• provide a textual description of what the query is doing.

We have improved the consistency of synthetic metrics. The metrics are now all grouped under the dash0Copy namespace. You can use dash0.spansCopy in the query builder to get the span count, dash0.spans.durationCopy for the span duration and dash0.logsCopy for the log count. For greater compatibility, we have also made it so that dash0.spans.durationCopy is interpreted as a native Prometheus histogram!

We have extended grouping capabilities for these metrics. Now can now group them by the dash0.*Copy, otel.span.*Copy and otel.log.*Copy attributes, e.g., dash0.operation.nameCopy and otel.log.severity_rangeCopy. Giving you more control than ever before!

Query builder showing a 90th percentile span duration, grouped by service name operation name.

The filter control is now a permanently visible input field. This notably improves the experience, aids discoverability, allows you to see already applied filters, and makes for a much more natural keyboard interaction.

We have also made the content of the filter popup much more intelligent. You can now see values immediately on the first page, guiding you and allowing you to avoid having to know all attribute keys by heart. Also go straight into search made when your input doesn't full match an existing value!

Easy search and filter – with suggestions for keys, values and direct access to thecommonly used filter operation.

We have been improving the dashboarding experience. Now, you can experience faster and more flexible dashboarding than before!

Starting with two new widget types, you can now visualize distributions using tree maps and pie charts. Both are handy for determining which pod is using the most memory or which service is generating the most errors.

Next, we have revised how we are showing unformatted series names. You know, those my_metric{service_name="shop", k8s_pod_name="shop-abcd"}Copy selectors that are used as fallbacks when no better name is available. These are now color-coded for easier reading, and the attributes are sorted in the same as within the filter dialog.

Last, we highlight the chart cursor position across charts for much easier visual correlation!

Dashboard showing a tree map, pie chart and a time series chart.

Dashboards are a very powerful tool to see all the telemetry for your specific use cases on one screen. Check rules are indispensable to get alerted when conditions in your system require human intervention.

Editing a dashboard or a check rule via Dash0's UI is probably the best way to get fast feedback, and iterate quickly. However, if you have a lot of dashboards or checks, at some point you might want to go with a more systematic approach. Configuration as code is the way to go.

The Dash0 Kubernetes operator now supports managing dashboards as well as check rules. Simply deploy them as Kubernetes resources, the Dash0 operator will automatically pick them up and synchronize them with your dashboards and check rules in Dash0. Additionally, you can also directly manage them via Dash0's API, if you want to do so from your CI system or via scripting.

Last but not least, Dash0 is committed to open standards. For dashboards, we use the emerging CNCF standard Perses, and for check rules we use the Prometheus rules custom resource definition. This enables you to build your dashboards and check rules with zero vendor lock-in.

You can read more about this feature here.

Here is an example for a Perses dashboard Kubernetes resource: https://github.com/dash0hq/dash0-operator/blob/main/test-resources/customresources/persesdashboard/persesdashboard.yaml

Now adding a fully configured Perses dashboard to Dash0 becomes as easy as executing the following one-liner:

0
kubectl apply -f persesdashboard.yaml

And here is how a Kubernetes resource for check rules looks like: https://github.com/dash0hq/dash0-operator/blob/main/test-resources/customresources/prometheusrule/prometheusrule.yaml

To deploy this to your cluster and have the Dash0 Kubernetes operator create the corresponding check rules:

01
kubectl apply -f prometheusrule.yaml
   

Resources are everywhere within Dash0: prominently within the resource map and table and explicitly called out within tracing, logging, metrics, and check rules. Starting today, resources are even more helpful.

We have thoroughly revised the sidebar and removed our modes concept from the resource map and table. The latter added unnecessary complexity and confusion. We also moved the table and map switcher to the main navigation, resulting in an overall much cleaner look without any information loss!

The hovercard now gained quick references to the reported signals in the footer, while we have reorganized the sidebar for clarity and visual hierarchy.

Within the sidebar, you can now always find the resource's health—with a dedicated tab for more details. Similarly, we have merged the requests, errors, and duration tabs into one, allowing us to switch between aggregations for these RED metrics!

The OpenTelemetry demo adservice within the resource table. Showing the sidebar RED-metric tab at the side.

Resources are also present whenever you look at spans, logs, and metrics. We also provide the same powerful hovercard-context experience within these locations. See a slow gRPC span? Quickly look up which service or Kubernetes pod is involved in the call!

The powerful resource hovercard is also available within all other areas where we reference resources.

The resource sidebar's telemetry tab has been showing information about tracing and logging data for some time. Now, we are extending it with details about metrics reported by a resource!

Resource sidebar's telemetry tab showing a metrics card.

You can quickly navigate to metrics available for a service or pod through the new metrics card. This card makes identifying whether a resource emits metrics easier and facilitates jumping into the metric explorer.