Changelog archive

Connect GitLab to analyze AI-assisted merge requests and their linked coding sessions in AI SDLC Insights.

The Dash0 Web SDK can now record user-sessions, allowing you to replay the actual user experience and correlate it with all web-events and backend-traces.

Notification channels now show their delivery status. When a destination fails, refuses, or Dash0 stops sending, the channel says why and how to fix it.

Stop notifications for a failed check for a fixed time, without a change to the check rule. Track, extend and end silences in the Silences Hub.

Share a custom skill with members, teams, or roles, and choose whether it starts enabled for them. Members can now create skills too.

Billing & Plans now breaks down your organization's Agent0 credits by source, consumer, model level and dataset.

Evals score your agents' generations as they arrive, with an LLM as the judge, so quality sits next to latency and cost. Write your own eval, then pick a trigger, a sample rate, and a numeric, boolean, or categorical verdict.

Move a dashboard or one of your saved views into a folder by dragging it there in the list. You no longer have to pick the folder in the Move to dialog.

AI SDLC Insights now has a Pull requests tab. See every pull request across your repositories with the AI sessions behind it, what they cost, and how long they took to merge, then drag across a heatmap to find the outliers.

Open any span and the full trace streams in instantly, even at tens of thousands of spans. Search by name, filter by type or errors, and see logs and span events directly on the timeline.

Dash0's AI SDLC Insights now supports GitHub Copilot App and OpenCode, giving teams more complete visibility into AI coding activity across their development tools.

Monitor the services your customers depend on, even the ones that never touch the public internet.

AI SDLC Insights now tells you what to do about your numbers, not just what they are. The Overview tab turns your coding-agent spend, adoption, and pull-request flow into a short list of recommended actions, each backed by the measurements it came from.

Agent0 now reads the same data as the AI SDLC Insights page, so its answers about coding-agent spend, adoption, and pull-request flow match the numbers you see. On the page itself, the Agent0 panel already knows which tab, range, and filters you are looking at.

Pin any page and it moves to the Pinned section at the top. Hover a collapsed section to open its pages without expanding it.

Agent0 threads keep running when you switch away, and the bottom bar shows which ones are still working and which have finished.

The Dash0 app has a new layout that puts your data first. Your content now sits on its own panel, the navigation around it is darker and calmer, and most separator lines are gone.

Automations are now editable only by admins and the members and teams you share them with, and every team and member page lists the automations shared with them.

New organizations can store their telemetry in AWS us-east-1 (N. Virginia), so US customers can hold their data on the east coast.

Admins can now import Agent0 custom skills from GitHub and GitLab, pick the ones they want, and pull in changes with one click.

A new dataset setting masks payment card numbers and replaces verification codes, PIN blocks, and track data in logs, spans, web events, and metrics before Dash0 stores them.

A new Forecast tab projects your spend for a full billing cycle, priced against your real tiers, right on the Billing & Plans page.

Automations now trigger on GitHub Actions workflow runs, jobs, manual dispatches, check runs and check suites, filtered by conclusion, status, branch or workflow name.

Uptime tells you your servers are fine. Service level objectives tell you your customers are, on any signal you already send to Dash0.

Install the operator in OpenShift via Helm and start sending your telemetry to Dash0.

The new sync-assets action keeps your dashboards and check rules in sync with your repo, right from CI.

Anyone with read access to a dataset can now create, edit, and delete Agent0 automations in it, the same way they already can with dashboards. Setting up an automation no longer needs an administrator.

Agent0 now runs on the model you choose. Pick a level per thread, per automation, or as your default for Chat, Automations, Slack, and MCP, and trade credits for capability where it matters.

AI Coding Insights becomes AI SDLC Insights. One page shows what your coding agents cost, who has adopted them, which tools and skills they lean on, and how AI-assisted pull requests move from first prompt to merge.

HTTP semantic-convention attributes on Lambda handler spans used to depend on your runtime — now the extension extracts them itself, for every language.

Teach Agent0 the procedures only your team knows. An admin can now write custom skills for your organization, and anyone can call one in a chat with /, or let Agent0 pick the right skill on its own.

SignalControl, now in every Dash0 account, filters, samples, and aggregates telemetry before anything is stored, so storage is billed only on what you keep.

Dash0’s Google Cloud integration now lets you filter the resources to monitor and select individual metrics to collect. Coverage also expands to Google Kubernetes Engine, Memorystore for Redis, and Compute Engine VMs.

Dash0 can now send failed checks, synthetic check failures and Agent0 automation notifications straight to Mattermost.

Available Dash0 plugins for Coding Harnesses (Claude Code, Cursor, Codex, GitHub Copilot CLI) are now available for Windows.

Message @dash0 directly to chat with Agent0 in a private thread. Your DMs carry their own organization and dataset, so you can ask about data your teammates do not work in without posting it in a shared channel.

Cardinality is now a metric. dash0.metrics.timeseries reports your distinct series count, so you can chart it, alert on it, and group it by metric name or by any resource attribute.

Every Dash0 alert in Slack now has a Fix this in thread button. One click asks Agent0 to explain the failing check, and the answer lands in the alert's own thread.

The Dash0 CLI now manages the whole lifecycle of your assets with the new, experimental apply --since option, which deletes assets based on Git history.

Dash0 now connects to GitLab, on gitlab.com or a self-managed instance. Agent0 reads the diffs, issues and pipelines behind your telemetry, so an investigation is grounded in the code that actually changed, and it can open a merge request when you ask. It works through your own GitLab account, so it reaches only what you can reach.

Mention @dash0 in a Slack channel to chat with Agent0 in the thread. It investigates alerts, finds your logs, builds dashboards and checks, and opens a PR with the fix.

You can now create deployment events and other log events via the Dash0 Terraform Provider through actions.

Time-series panels can now show your deployments as markers on the timeline, colored by whether the deployment succeeded or failed. Send a dash0.deployment log event from your pipeline and every chart can tell you when the code changed.

Write action approval is a new Agent0 setting that makes Chat stop and ask you before it does anything that writes. Organization admins turn it on in Settings → Agent0.

The Dash0 Operator for Kubernetes v1.151.0 introduces automatic instrumentation support for Ruby 3.3+.

Agent0, Dash0's observability agent, can now be reached from Claude Code, Cursor, or any MCP client. Rather than your assistant running one query at a time, ask "why did checkout get slow at 14:00" and Agent0 investigates across your metrics, logs, traces, and profiles, then tells you what broke and why. It uses Dash0 credits, and organization admins can turn it off for everyone.

Any query in the Log Explorer, Trace Explorer, or Web Events Explorer can now be exported to a file. The button sits in the table header next to the display menu, with CSV as the primary action and TXT, JSON, and YAML in the disclosure menu.

You can now manage Dash0 teams as code using the Dash0 CLI, Terraform provider, and Kubernetes operator, so team definitions live in the same repository, review process, and rollout pipeline as everything else.

The new Spans Table widget brings a sortable, self-refreshing table of spans to your dashboards and the query builder.

The old "Events & Logs" tab in the span sidebar is now "Related logs & events", offering you a one time-ordered list that interleaves log records and span events across the whole trace, resource, or both.

Full AWS Lambda observability is now in Dash0. Connect your account and see every function immediately, instrument to get traces with event payloads, correlated logs and synthetic traces for the failures that never produce telemetry.

Agent0 investigates, fixes, and reports on its own, triggered by Slack messages, GitHub events, failed checks, webhooks or a schedule. No one has to be in the loop. Unless you want to. You are in control.

Spam filters keep unwanted telemetry out of Dash0, but until now they worked silently. Each spam filter now comes with a chart showing exactly how much data it dropped over time, so you can tell at a glance which filters are earning their keep and which ones have gone stale.

We reworked how Dash0 renders high-cardinality charts and scrolls long lists, so the busiest views stay responsive as your data grows.

Your web event annotations now appear as pins right on the GeoMap, so you can see where in the world your users are hitting errors, not just that they are. Plus a new city reference layer and trackpad pinch-to-zoom.

Dash0 now collects metrics for your Cloud SQL instances automatically. Connect a GCP project and see CPU, memory, and disk utilization, connection activity, and engine-specific performance for PostgreSQL, MySQL, and SQL Server, with no dashboards to build.

Browser-based OAuth login, a local OTLP forwarder for in-loop development, precision-mode queries for exact lookups, and a one-command Homebrew install — all in one release.

Connect MCP servers to Agent0 securely with OAuth — authorize once and skip manual token handling.

The new MCP catalogue lets you browse a curated list of MCP servers and connect them to Agent0 in just a few clicks, right from the Integrations Hub.

We’ve replaced the fixed 10/30/60-second refresh picker with a single toggle, so Dash0 now keeps every chart and table fresh at the right cadence on its own.

Agent0 is now Generally Available (GA) inside Dash0. The old assistant has been replaced by an autonomous production AI built on a new execution runtime, with continuous environment scanning, full-loop investigation, and pull request generation against your codebase.

Correlate spikes and dips in your time-series charts with what real users were doing. Web events from RUM can now be overlaid as annotations, alongside the existing log, Kubernetes, and service event sources.

The OpenTelemetry K8s SIG has introduced new semantic conventions for replication controllers, horizontal pod autoscalers, persistent volumes and their claims, resource quotas and more. We added support for them in Dash0, alongside first-class support for the k8sobjectsrecevier and its (non semconv-compliant...) output.

When troubleshooting slow or failing database queries, knowing which query ran is the first thing you need, but finding it buried in the Attributes tab is painful. Now it's front and center in the span sidebar, syntax-highlighted, with prepared statement parameters already filled in.

When you spot something unusual in a chart — a sudden spike in a logs chart, a latency outlier, an error rate climbing on one service — the next question is always the same: which records actually caused this? Dash0 now gives you a direct way of answering this question. Select a time range or on a chart, click a pie segment, or click a stat value, and an action bar appears with Explore and Triage actions that take you straight into the matching signal explorer with filters and time scope already applied.

The Integrations Hub now ships 101 curated check rules like Kubernetes, Vercel, AWS RDS, Istio, Argo CD, Cilium, the OpenTelemetry Collector, and many more.

Spam filters in Dash0 let you drop unwanted logs, spans, and metrics before they reach storage by matching on structured attribute conditions. You can now manage spam filters as code using the Dash0 CLI, Terraform provider, and Kubernetes operator, so your data-hygiene rules live right alongside the rest of your infrastructure.

Dashboard queries that aggregate large volumes of raw metrics can be slow and expensive. You can now define recording rules as code using the Dash0 CLI, Terraform provider, and Kubernetes operator, so pre-computed time series are version-controlled and deployed alongside the rest of your infrastructure. Recording rules let you evaluate PromQL expressions on a schedule and store the results as new time series. This means dashboards and alerting rules can query the pre-computed series instead of recalculating them on every load. You author rules in the standard `PrometheusRule` CRD format (`monitoring.coreos.com/v1`), so the syntax is already familiar if you have worked with the Prometheus Operator.

Google Cloud infrastructure monitoring is now in Dash0. Cloud Run, Pub/Sub, and Cloud Storage metrics flow the moment you connect a project — no setup required.

Notification channels and the associated routing rules join the Dash0 settings you can manage as Infrastructure as Code in Dash0.

Dash0 SQL is now generally available. Write queries directly against your logs, spans, and web events — with templates to start fast, query history to revisit past work, and saved views to persist queries and share with your team.

Need more room for that service name? Now you can drag column edges to resize tables in Trace Explorer, Log Explorer, Web Events Explorer, and Resources.

Running multiple sites on a single web integration? Now you can finally see which domain each session came from.

Connecting your AI coding tools to Dash0 just got a lot simpler. Dash0's MCP server now supports OAuth 2.0 authentication, so tools like Claude Code, Cursor, Windsurf, and other MCP-compatible clients can authenticate without requiring you to create and manage static API tokens.

Chart legends now behave the same way everywhere in Dash0.

When a check fails, the first thing you want to do is understand why. Until now, drilling down from a failed check into the underlying telemetry meant losing context — metric filters weren't carried over, and the charts you landed on showed largely unfiltered data, often not relevant for your investigation. Dash0 now provides a seamless drilldown experience from failed checks directly into the relevant spans, logs, web events, and metrics — with filters automatically extracted from the check's PromQL expression.

The Query Builder just got a major upgrade. We've unified it with the dashboard panel editor, giving you a cleaner, more consistent experience, and a few quality-of-life fixes along the way.

Binary operations in PromQL silently drop results when one side of the expression has no matching time series. If you divide requests by capacity, and a new instance hasn't reported capacity yet, that instance vanishes from your chart — no error, no gap, just missing data. This makes dashboards unreliable and alerts blind to exactly the moments that matter most. Dash0 now supports the fill modifier for binary operations, giving you explicit control over what happens when one side of an expression has no match.

Span events are being deprecated in OpenTelemetry. With one click, you can transform them into logs in Dash0.

Investigating a single log record rarely tells the full story. The new Related Logs tab surfaces the surrounding context — every log from the same resource and trace, organized chronologically around the record you're inspecting — so you can reconstruct what happened without leaving the sidebar.

Dash0 now supports exporting audit logs to external systems using the OpenTelemetry Protocol (OTLP). Stream organization-level audit events, including user actions, configuration changes, and access activity, to any OTLP-compatible backend, SIEM, or long-term storage system. Built on OpenTelemetry standards, this capability integrates natively with your existing observability and compliance tooling, giving security and platform teams full control over where audit data lives and how long it is retained.

AI coding agents are rewriting how teams build and operate software. But most CLIs were designed for humans — with colored tables, interactive prompts, and prose help text that agents struggle to parse reliably. Agent mode makes the Dash0 CLI a first-class tool for AI coding agents, with zero configuration required.

The Dash0 Terraform Provider is now also available on the OpenTofu registry.

Visualize the full topology of your distributed traces, dependencies, cross-boundary interactions, and service relationships, for faster root cause analysis.

Change the operator on an existing filter and keep the values you already picked. No more re-selecting the same things twice.

AI coding agents are transforming how teams write code, but they have a blind spot: observability. When an agent scaffolds a new service or adds a feature, it rarely sets up instrumentation — and when it does, the result is often noisy, non-standard telemetry that obscures more than it reveals. Dash0 Agent Skills close that gap.

Monitor the complete Kubernetes cluster with one command

Auth tokens already support restricting ingestion to specific datasets. Now, tokens can also be restricted to individual signal types — logs, spans, metrics, profiles, or web events — giving you fine-grained control over what data each token is allowed to send.

When investigating issues in production, the first question is almost always "what's different about the errors?" Until now, the Triage panel in the Trace Explorer, Logs Explorer, and Web Events Explorer defaulted to comparing against the current timeframe — a useful but generic baseline that required an extra click to switch to error comparison. Starting today, all three explorers default to error comparison mode. The triage panel immediately highlights which attributes correlate with errors, so you can jump straight into root-cause analysis without changing any settings.

Stack traces from minified JavaScript are now automatically translated into their original source locations.

Every metric, attribute, and event that Dash0 adds to your telemetry is now defined in a public, machine-readable registry. The Dash0 Semantic Conventions give you a single place to look up what each field means, where it comes from, and how to query it.

Agent0 now integrates with Linear, bridging project management and observability to bring issue context directly into debugging and investigation workflows in Dash0.

Admins can now mark any dataset as preferred for the organization. Dash0 opens the preferred dataset by default for all members of the organization unless a different dataset is specified in the URL or if they previously visited a different dataset.

Infrastructure as code changed how teams manage servers. The same principle should apply to observability: your dashboards, alerting rules, views, and synthetic checks deserve version control, code review, and automated deployment. The Dash0 CLI gives you full CRUD control over all four asset types, plus the apply command that brings GitOps workflows to your observability configuration.

A slow API call rarely tells the whole story. To understand why a request took 3 seconds, you need to see every hop it made: the database query, the downstream RPC, the cache miss that should not have happened. Now you can explore all of that without leaving the terminal. The Dash0 CLI introduces two commands for distributed tracing: spans query to search across spans, and traces get to reconstruct a full trace end-to-end.

Every investigation involves logs at one point or another. With the dash0 CLI, you can search, filter, and inspect log records stored in Dash0 without leaving your shell.

You can now programmatically automate and manage your organization's members and teams using our full suite of interfaces.

The filter bar across all Dash0 explorer pages has new capabilities for managing filters across pages, resolving conflicts, and copying individual filters.

Overlay events on any dashboard chart to see what changed alongside your metrics.

Telemetry export and API sync now support multi-cast to any number of backends

Dash0 now recognizes any structured log record using the `otel.event.name` attribute or field as a log event.

Tailor your workspace with the new Light Mode theme.

Set a hard monthly spending cap on your Dash0 organization to make sure you never pay more than you expect.

We're excited to announce the general availability of the Dash0 CLI — a command-line interface that brings Dash0 asset management to your terminal, CI/CD pipelines, and automation workflows.

The Lookout Agent brings AI-powered web analytics and frontend performance monitoring to Agent0, helping you investigate issues and understand user experience through natural language conversations.

Turn any Dash0 feature into a composable link with parameters for maximum flexibility.

We've increased the retention period for synthetic API check runs from 30 days to 13 months at no extra cost. This change applies to all check runs executed from January 19, 2026 onwards. Existing check runs will continue to follow the previous 30-day retention policy.

Telemetry export and API sync now support per-namespace configuration to enable more flexible routing.

Build smarter and monitor better with 5 new AI integrations. Connect AI tools to your telemetry for context-aware coding, or track LLM performance, costs, and agent behavior in production.

As observability grows, dashboards and alerts quickly pile up. Without structure, it becomes difficult to navigate and maintain clarity. That’s why Dash0 now introduces Folders.

Today, we’re launching Dash0 Services in Beta. We’ve turned your OpenTelemetry data into a real-time, living map of your entire system. No proprietary agents, no manual configuration - just the payoff for the instrumentation work you’ve already done.

Check rules can now query Dash0's own check metrics (dash0.check.*, dash0.issues.*, dash0.synthetic_check.*), enabling higher-level alerts based on the status of other checks.

You can now sort by Query name across all supported chart types, making it easier to organize multi-query panels exactly how you want them.

Calculations are an important element of many dashboard panels: they allow you to “summarize” a timeseries into one single data point, which is precisely what you need for Pie charts, Stats charts and more. But they are pretty difficult to understand. If you have ever wondered what "First non-null value" actually means for your panel calculations, you are not alone. We've added interactive visual examples to every calculation type selector, so you can see exactly how each option works before you choose it.

Dash0 now supports AWS PrivateLink for secure, private connectivity between your AWS VPC and Dash0's ingestion endpoints.

Building on top of the extended support for Kubernetes events in the core product, our operator now also automatically collects Kubernetes event data.

Ever been working in a dashboard only to suddenly find yourself back on the homepage? That frustrating experience is now fixed (and we are sorry). Let us make it up to you by explaining to you how it happened and how we figured it out.

We’re simplifying how alerts are routed in Dash0. Notification channels can now be assigned directly to check rules, and you can route alerts based on severity, giving you precise control over which alerts reach which channels.

We have just improved our support for Kubernetes by adding out-of-the-box support for Kubernetes events collected through the k8seventsreceiver In the OpenTelemetry Collector.

Fine-tune on which nodes operator pods should be scheduled.

Made a change to your dashboard and want to go see how it was before? Now you can. We've added the ability to view and restore previous versions of your dashboards.

Configure the collection of your metrics by using familiar CRDs.

Not every dataset should be treated the same. For example production needs guardrails; development needs freedom. With this release, Dash0 introduces dataset-level permissions, giving you a simple but powerful way to decide who can do what inside each environment.

The Dash0 operator now supports GKE Autopilot.

Tired of having to switch to PromQL mode just to be able to use dashboard variables? Today, we change that.

Added the ability to hide charts in explorers, web monitoring sessions and resources, for increased usability of the tables, triage and grouping capabilities.

Dashboard charts now support saving sorting configuration across multiple chart types. Sorting controls have also been unified into one location in the sidebar, along with the ability to simply click and sort on the charts themselves.

That latest releases of the Dash0 operator for Kubernetes adds zero-touch auto-instrumentation for .NET workloads.

Dash0 now supports OpenTelemetry Exponential Histograms for a more accurate, high-resolution metric visualization.

With this release, Access Control in Dash0 is now complete: all observability assets - including dashboards, views, check rules, and synthetic checks can be shared with Teams and individual users.

Bring your logs directly into your dashboards for unified observability

TV Mode now supports opening and viewing dashboard panels, enabling teams to inspect detailed metrics and queries while maintaining the distraction-free full-screen experience.

The Dash0 Web SDK for Website monitoring now supports AWS X-Ray trace propagation, enabling seamless end-to-end tracing for applications using AWS managed infrastructure.

We are thrilled to announce the launch of our new Audit Logs feature. This powerful tool provides a chronological record of activities.

We’ve added the ability to create Teams in Dash0, making it easier to manage permissions and share assets across groups of users.

We just opened to everybody the first Dash0 region based on GCP, based in the Netherlands.

We’ve expanded our global synthetic monitoring network with three new locations, giving you more flexibility and accuracy when testing your applications worldwide.

Expand your observability infrastructure as code capabilities with declarative management of check rules and custom views.

The Dash0 operator now supports managing synthetic checks as infrastructure as code.

Dash0 now supports routing of failed check notifications via labels to Slack, Email, and all of our other notification channels.

Synthetic monitoring generates continuous simulated traffic from multiple locations, letting you catch problems before anyone opens a support ticket.

We've completely redesigned Organization Settings to make managing your workspace simpler, faster, and more intuitive.

Get complete visibility into your AWS workloads with automatic span collection from fully managed services like API Gateway, Lambda, SNS, SQS and many more. No code changes required—just enable the integration and see the full journey your requests take through AWS infrastructure.

We now allow users to share custom views across the organization.

We're introducing the hosted Dash0 MCP (Model Context Protocol) Server, designed to facilitate advanced interactions with your observability data.

Dashboard filter variables now support dependency relationships, enabling powerful hierarchical filtering workflows.

We’re excited to announce that Dash0 is now available in the AWS Marketplace!

We've enhanced our tooltips to make data exploration more powerful and intuitive. You can now hold down the Option/Alt key (⌥) when viewing certain tooltips with a lot of data (charting e.g.) to make it "sticky" - allowing you to move your mouse freely inside the tooltip to interact with its content.

Dash0 now supports automatic parsing and enrichment of NGINX access logs—no regex, no pipeline tweaks, built-in for everyone.

Alerting Webhooks now support automatic redirect following and connections to internal/dev endpoints with self-signed certificates (use the latter with extreme caution).

Dash0 now natively integrates with for All Quiet, a modern incident management platform. With this integration, you can now automatically forward all Dash0 check rule failures to All Quiet - ensuring your team can manage and resolve Dash0 issues faster and more efficiently.

We're excited to announce the release of two powerful new alert integrations: Jira Service Management Ops and Opsgenie! These integrations are designed to streamline your incident management process and ensure you're always on top of critical issues.

We're excited to announce our new Hierarchy Map widget, which provides an intuitive way to visualize a large number of resources and their relationships in a condensed and clear manner. This powerful visualization helps you quickly understand the structure and health of your infrastructure as you wish.

The dash0-enabled annotation allows you disable or enable of check rules in Infrastructure-as-Code.

We're excited to announce the release of our two new alerting integrations "ilert" and "Discord". These integrations provide real-time notifications, similar to already existing integrations like Slack Webhook or Google Chat, ensuring you stay informed about critical issues as they arise.

Dash0 now supports a Terraform provider to manage your configuration as code.

We are thrilled to introduce two new integrations that enable you to receive real-time alerts directly in Microsoft Teams and Google Chat. This enhancement ensures you are immediately notified of critical issues and can act swiftly to resolve them.

Our LogAI now identifies patterns in your log messages and uses them to extract type-safe, named attributes that you can use in queries, filters and grouping and, last but not least: triage.

We’ve introduced a new Home Page that gives you a high-level overview of all telemetry sent to Dash0, including metrics, logs, traces, and alerts—so you can spot issues faster and stay on top of your system’s health at a glance.

We're excited to announce our new integration with PagerDuty, which enables you to use PagerDuty as a notification channel.

We are pretty fond of the growing OpenTelemetry support in Linkerd.

We've just added a new feature to our recently released Slack Bot integration: chart images. This update provides an enhanced way to visualize and understand your alerts directly within Slack.

We love interacting charts. We think you should be able to get answers by interacting with data visualizations in intuitive ways. This is why since early on, Dash0 allowed you to focus on a smaller timeframe by creating a selection on a chart and using the Set Time Range button.

With the latest release of the Dash0 operator, you now have not only one, but two powerful mechanisms to only collect the telemetry you really need in your Kubernetes clusters: Filters and transformations. Both capabilities help to reduce the noise in your telemetry, let you focus on what really matters to keep your services running smoothly, and ultimately also help to save hard cash.

We taught Dash0 to leverage the wealth of telemetry metadata you send to find commonalities, differences and patterns. We call it Triage, and it is a pretty simple experience: you draw a box around what interests you, and let Dash0 tell you why it is so very interesting.

OpenTelemetry, Prometheus and other open-source projects have made telemetry open, easy to collect and plentiful. Too plentiful, sometimes: not all telemetry is equally valuable to everyone.

The Dash0 operator can now filter with namespace-specific rules the telemetry it collects before sending it to Dash0. This feature is the "client-side" equivalent of Dash0's Spam filters, which also becomes available today.

Tired of sifting through endless streams of logs and traces? Within the Logging and Tracing Explorers, you can now group by attributes to quickly get an overview! Grouping unlocks yet another way to iteratively reduce the amount of data you are sifting through to get from data to answers.

The Tracing Heat Map is very powerful and provides an intuitive way of detecting outliers in terms of slowness or clusters of errors in the blink of an eye. (And now with no more Lost in Time issues, getting a first peek at the offending spans is so easy!)

Introducing a series of email-centric alerting enhancements designed to provide more insights at a glance.

Dash0's new Slack Bot integration delivers real-time notification, threaded status changes, and quick-access links directly to your Slack channels reducing alert fatigue efficiency.

Dash0 can now automatically update attributes (for Resources, as well as Spans, Logs and Metrics) to their latest naming as defined according to the OpenTelemetry semantic conventions.

We just deployed a Dash0 region in North America, based on the AWS us-west-2 (Oregon) region!

We removed Dash0's base subscription fee, moving to a purely consumption-based model with the same rates we have had from the beginning.

A lot of the logs that are sent to Dash0 are unstructured: they are strings of text, with important information like severity, “hidden” inside the message. Until recently, such logs have been marked in Dash0 logs as having severity UNKNOWN. But this is a thing of the past.

Meet dash0.span.events — our newest synthetic metric designed to provide deeper visibility into the events associated with your trace data.

Dash0-specific Prometheus alert rule extensions are now available behind the dash0- prefix in the Dash0 operator's 0.37.1 release, ensuring a clear distinction from all other labels and annotations.

To help everybody get started with their observability journey, the Dash0 Integrations Hub is now available.

We’re introducing a new notification channel in Dash0 that allows you to send alerting notifications to an external Prometheus Alertmanager. This integration enables Dash0 to work alongside tools in the Prometheus ecosystem, offering flexibility for teams already using Alertmanager as part of their alerting infrastructure.

Semantics are essential to turning data into information. In dashboarding, the person crafting the dashboard is responsible for making this a reality. One thing that has always been annoying is the coloring of time series.

The Dash0 operator version 0.37.0 introduces out-of-the-gox support for collecting traces, metrics and logs from Java applications.

We just released our brand new Vercel integration. It makes sending your Vercel logs to Dash0 a breeze.

Dash0 now supports extraction of context from journald logs. The severity levels from the Journald logs are now mapped to OpenTelemetry semantic conventions, allowing for more consistent log analysis.

The Dash0 Kubernetes operator now automatically adds Kubernetes resource attributes to all workloads that are deployed with an OTel SDK.

With our latest update, you can now create custom views tailored to your needs and star your favorites for quick access.

Dash0 will now remember your last changes and indicate that you have a pending dashboard modification. Whether you accidentally refresh, close the tab, your browser crashes, or continue editing in a different tab, Dash0 will keep your changes and allow you to continue where you left off.

Sidebars in Dash0 carry essential information about telemetry, context, and configuration. With the latest update they are now resizable too.

Our log ingestion pipeline now uses AI to understand the log structure of your applications and automatically extract the severity information.

Our predefined filters and column configurations for Logs and Traces make it easier than ever to dive into the topics that matter. Quickly apply these views to focus on the data relevant to your use case, helping you get to the insights you need faster.

You can now easily send logs to Dash0 using the most commonly used observability pipelines and log shippers! The onboarding dialog now shows you how to configure new options – including a particular version for Amazon EKS on Fargate (which is especially fun)!

PromQL can be difficult to understand. Dash0 now helps you understand queries using generative AI (genAI). With our quick reference, you can also see whether the referenced metrics exist and click them to go to metric explore.

Dash0 synthetic metrics are now available under the dash0.* namespace, and we have expanded the grouping capabilities!

Searching and filtering for the data you are about is central to your observability experience. Now, we have made the experience even better.

Dashboards are flexible and allow easy tailoring to your needs. They are now improved with tree maps, pie charts, and more!

Managing dashboard configurations and check rules manually can become a huge burden. Now you can take back control over both of these with the Dash0 API or with the Dash0 Kubernetes operator.

Resources are a cornerstone of OpenTelemetry, and we have revised how we show information about them.

The resource telemetry tab is now complete: Showing reported metrics and allowing navigation.