Recent changes and improvements to Dash0

Now they hand over a whole task, and Agent0 investigates it against your live environment, works out which queries to run, and reports back into the conversation you are already having.

That widens what is worth asking. A direct query answers a known value, such as one service's p95 latency over the last hour. Agent0 takes the open-ended work: why a service got slow, what caused an incident, which dashboards and alerts a renamed metric will break.

Agent0 investigates and reports. It does not change your systems. The only things it produces are dashboards and alerts, proposed for you to review and create yourself, so nothing is written to your code or your tools without you.

Short questions come back in seconds. A real investigation takes longer, so your assistant gets a link, and Agent0 keeps working in the background, then delivers its answer when the run finishes. Open the link to watch the investigation in Dash0 and see which telemetry it used.

Agent0, through the MCP server, consumes Dash0 credits, exactly as a conversation in the Dash0 UI is, whether a message starts a thread or continues one.

The active query defines the file, not how far you scrolled. Filter, time range, ordering, and dataset are what get exported, so the same query exported twice gives you the same records. For spans and web events that includes a focused duration range picked on the heatmap, because that selection is part of what the table is querying.

Exports include up to 5,000 records. Beyond the cap, use the Dash0 CLI. The menu builds the command for your current query, ready to copy.

Each team is modelled as a CRD:

team.yaml
12345678910111213141516
apiVersion: dash0.com/v1alpha1
kind: Dash0Team
metadata:
  name: backend
  labels:
    dash0.com/id: team_01kvdm62v1e1hrz93egm447bxw
spec:
  display:
    name: Backend
    description: Owns backend services and the data platform.
    color:
      from: "#6366F1"
      to: "#8B5CF6"
  members:
    - alice@example.com
    - bob@example.com

You can download the YAML of a team from its page in the Organization settings:

Dash0 CLI

Support is added in the CLI version v1.16.0 and above.

The teamsCopy command tree is currently experimental and requires the --experimentalCopy (-XCopy) flag; applyCopy picks up kind: Dash0TeamCopy documents without any flag.

1234567891011121314
# Create or replace a team from a YAML file
dash0 apply -f team.yaml

# List all teams
dash0 -X teams list

# Get a team as YAML (round-trippable with `apply -f`)
dash0 -X teams get <origin-or-id> -o yaml

# Update a team by re-applying the edited YAML
dash0 apply -f team.yaml

# Delete a team
dash0 -X teams delete <origin-or-id> --force

The exported YAML round-trips through apply -fCopy without post-processing, and membership renders as email addresses on read regardless of whether the write used emails or internal ids.

Terraform provider

With the Terraform Provider for Dash0 v1.15.0 and above:

team.tf
123456789101112131415161718
resource "dash0_team" "backend" {
  team_yaml = <<-YAML
    apiVersion: dash0.com/v1alpha1
    kind: Dash0Team
    metadata:
      name: backend
    spec:
      display:
        name: Backend
        description: Owns backend services and the data platform.
        color:
          from: "#6366F1"
          to: "#8B5CF6"
      members:
        - alice@example.com
        - bob@example.com
  YAML
}

Kubernetes operator

Using the Dash0 Operator for Kubernetes v1.50.0, create the Dash0TeamCopy resource in one of your namespaces with a Dash0MonitoringCopy resource and your team will be synchronized with the Dash0 backend.

Your dashboards could already pin a live Logs Table, but spans had no equivalent. If you wanted to see raw spans next to your charts, say the slowest requests to an endpoint or every span carrying an error, you had to break away from the dashboard and jump over to the Trace Explorer.

Now you can add a Spans Table widget to any dashboard. It fetches spans on its own and shows them in a sortable table. Sort by start time, duration, or status code, pick exactly the columns you want (name, service, duration, span kind, status, and more), add any attribute as its own column, and scope the whole table with filters and dashboard variables.

Every row links straight into the Trace Explorer and carries your columns and filters with it, so a single click takes you from the dashboard to the full trace and span detail with nothing to set up again.

The result is a dashboard that can show live spans right beside your metrics and logs, so the traces that matter stay in view instead of a tab away.

Pick how "related" you want to see

A dropdown at the top of the tab lets you switch between four correlation scopes:

• Trace (default): every log record and span event in the same distributed trace as this span. Best starting point for reconstructing a request.
• Resource: everything on the same service within ±30 minutes of the span. Handy when the interesting logs live outside the span's own trace context (background jobs, scheduled tasks).
• Resource & Trace: the union of the two above.
• Span: only the log records and events directly attached to this span. Same behaviour as the old "Events & Logs" tab.

The list places the span in context

Inline marker rows show exactly where "This span started" and "This span ended" sit within the surrounding stream. Older records appear below, newer above. When you paginate away and click the duration pill above the list, it snaps you back to the span-start marker. Or, if you've drifted far enough that the marker is out of the cached window, it re-fetches around the anchor and centers there.

Deep links from the trace tree still work

Clicking an event in the trace tree scrolls the list to that event and briefly highlights the row, so navigating from a span's timeline into the surrounding logs keeps your place.

Same primitive on both sides

The tab is built on the same virtualized list, cursor pagination, and row layout that the log sidebar's Related Logs tab already uses. Both sides share behaviour, keyboard focus, and infinite-scroll semantics.

Lambda observability used to mean gluing together CloudWatch and X-Ray, hand-managing OTel layers per function, and building dashboards from scratch, per account, per region, just to see which functions were erroring or cold-starting. And it drifted the moment someone redeployed without the layer.

Now you connect your AWS account to Dash0 and see your Lambda functions, invocations, errors, duration, and cold starts, with no dashboards or queries to set up.

What's included

One-click AWS account connection. Connect via CloudFormation in under five minutes. Dash0 uses cross-account IAM role assumption, so no credentials are stored on Dash0's side. Terraform and CDK paths are available for infrastructure-as-code teams.

Lambda resource catalog. Every Lambda function appears with invocation counts, error rates, duration, and cold start metrics, across all connected accounts and regions. Click any function for a full metrics breakdown and an invocation table filterable by result, duration, and memory usage.

One-click instrumentation from the UI. Instrument functions without touching code or managing layers. Dash0 runs pre-flight validations, adds the Lambda Layer, and tracks status per function. Python, Node.js, and Java supported. Redeploy without the layer and Dash0 detects the drift and re-instruments automatically.

Drill-through to traces and logs. Jump straight from any function's detail page to its traces and logs.

Synthetic traces for timeouts and OOM. When a function is killed by a timeout or out-of-memory error before it can emit telemetry, Dash0 creates a synthetic trace with the duration, trigger source, and context around the failure.

Payload capture. The full event that triggered the function is attached to every trace. Outgoing calls to downstream AWS services are captured too, including request and response bodies. Sensitive values are masked by default.

To get started, go to Integrations and select Connect AWS account.

Automations are event-driven AI workflows that Agent0 executes on your behalf. You define what to watch and what to do. Agent0 runs the investigation, traces the cause, and delivers the result — no human needs to be in the loop for any of it.

Agent0 automations are GA from today and, as such, consume Agent0 credits on each run.

What's new

- Event-driven triggers: Respond to Slack messages, GitHub pull requests, failed checks, Linear comments, or run on a schedule.

- AI-powered execution: Agent0 analyzes context, queries your Dash0 data, and takes action based on the instructions you write.

- Guardrails you control: Read actions run automatically. Write actions like opening a pull request are off by default — you allow or deny tools per automation, explicitly, before anything runs.

- Concurrency management: Choose how simultaneous triggers are handled with parallel, queue, skip, or supersede policies.

- Notifications: Findings are delivered to Slack, email, or Dash0 with a direct link to the full investigation.

- Templates: Start from a catalog of pre-built automations for incident triage, PR review, SLO monitoring, and more, or build one from scratch with a full-view prompt editor.

A few things teams are already running

- Catching regressions before users do, by triggering a health check on every deployment.

- Turning a failed check into a drafted fix and a Slack message with the root cause, before anyone opens a laptop.

- A daily production briefing that scans for degrading services, coverage gaps, and unresolved issues.

- Continuous PII monitoring across logs and traces on a schedule.

Read the Automations documentation to get started.

See how much your spam filters catch

Open the spam filter settings and every filter shows its own time series of dropped signals. Log records, spans, metric data points, and web events are each counted separately. A filter that has been quiet for weeks is a candidate for cleanup, while one that suddenly spikes might be telling you that a service started misbehaving upstream. Either way, you no longer have to guess whether a filter is actually matching anything before you edit or delete it.

Under the hood, every dropped signal is now attributed to exactly the filter that matched it.

You can alert on it too

These charts are powered by the dash0.spam_filters.{logs,metric_data_points,spans,web_events}Copy. They are metrics we record for you and you do not pay for, and you (or Agent0) can use them to create your check rules.

We changed what happens under the hood. High-cardinality line, bar, and pie charts now paint their data as a single lightweight layer instead of thousands of individual shapes, so hovering and updating stay responsive even at very high series counts. Initial load times are also improved.

We also made scrolling lighter in Logs, Traces, and the Web Events Explorer, so paging through thousands of rows keeps up with you (especially in Safari).

The result is the same Dash0 you know, just smoother where it used to strain. Dense dashboards feel snappy, hovering across a crowded chart no longer stutters, and scrolling thousands of rows in Logs, Traces, and the Web Events Explorer stays fluid.

We also fixed a related pie chart issue: a chart with many empty or zero value series could render blank. Those empty series are now skipped, so your real data always shows.

We will continue to improve the performance of some more charts in the upcoming months.

Until now, the GeoMap could color countries by value, but the events behind those numbers (a spike of web errors, a burst of failed requests) lived in a separate timeline with no sense of place. You could see that something happened, but not where your users actually were when it did.

Now your web event annotations show up as pins on the map. They render with the same markers, tooltips, and severity colors you know from the event timeline, placed by the geographic data Dash0 already enriches onto web events. Turn them on from the panel's annotation settings, exactly like you would on a time-series chart, and a regional error pattern that used to be buried in a timeline becomes obvious at a glance.

As you zoom out, nearby pins cluster into a single bubble that grows with the count and takes on the most severe color in the group; zoom back in and they split apart again. Hold Alt/Option to pin a tooltip open so you can click straight through to the underlying events.

The map also reads exact coordinates and locality when your telemetry carries them, so if you instrument other signals (logs, Kubernetes, or service events) with geo data of your own, those land on the map too. The pins resolve from the standard OpenTelemetry geo attributes: https://opentelemetry.io/docs/specs/semconv/registry/attributes/geo/

We shipped two extras alongside it. A new "Show Cities" toggle overlays reference points for major cities and towns, giving you orientation as you pan and zoom below the country level. And on macOS, trackpad pinch-to-zoom now works directly on the map instead of zooming the whole page.