The Dynatrace MCP Server is now available in Port via Port MCP Connectors. A single OAuth flow connects it in minutes. Set up Port AI to communicate with Dynatrace, GitHub, Slack, and your service catalog in a single conversation, correlating production signals, code, and ownership in a single agent run rather than three browser tabs and a manual handoff. For incident triage, this turns a multi-tool investigation into a single prompt: just ask Port AI what’s wrong; you’ll get details about the failing service, the error signature, the file and function, and the suspect commit.

Ground every Port AI conversation in live production data from Dynatrace

Port is an agentic engineering platform that platform teams use to organize their software development lifecycle. It gives software and DevOps teams a central place where engineers can find system information, take action on it, and route work across their connected tools, without waiting on IT or operations.

Port AI is the assistant that queries the catalog using natural language. Through Port MCP Connectors, the same chat also reaches external systems, such as Dynatrace, GitHub, and Slack.

Dynatrace complements Port by providing context-rich observability and security insights, right where you need them:

The result: Team members ask a question in the Port AI chat, where they’re already working, and get back complete answers that no single tool could produce on its own.

Incident triage from a single Port AI prompt

The Dynatrace MCP Server provides Port AI with a set of tools it can call during any conversation. For incident triage, the most relevant needs are:

• Query production data. Logs, traces, metrics, and events from across the Dynatrace tenant returned in structured form.
• List open problems. An overview of all active problems on the tenant.
• Get problem details. Root cause, causal chain, and affected entities for a specific problem.
• Get troubleshooting guidance. Relevant troubleshooting guides matched to a problem description.

The full toolset also covers security findings, entity and topology lookup, query generation, forecasting, and more. See the Dynatrace Hub for the complete list. In combination with Port AI, these capabilities turn the Port AI chat into a single place to ask production questions.

The example below walks through the triage of an incident affecting broker_service, a fictional service. The same investigation, done manually without this integration, starts in Dynatrace (where the failing service shows up in seconds), then jumps to GitHub to scan recent commits, to Slack to confirm ownership, and back to a doc to write up the summary. With this Port AI integration, those steps run in a single agent run, with the Dynatrace signal at the center of the chain.

The scenario begins when broker_service degrades and lands as a new incident, INC-1003. In Port AI chat, an SRE asks, “Help me understand the root cause of INC-1003.”

Port AI loads the ai-incident-triage skill and runs the following steps:

1. Resolve the incident in Port’s catalog. Port AI looks up the incident entity and pulls the affected service identifier.
2. Query Dynatrace. The Dynatrace MCP Server queries logs and traces for broker_service. The response carries the first-seen failure timestamp and the top error signature.
3. Find the suspect commit in GitHub. Port AI passes the failure window to the GitHub MCP Server, locates the failing function, and lists the commits to that file. One commit aligns with the first-seen timestamp.
4. Return a structured triage summary. Port AI returns the failing service, the error signature, the file and function, and the suspect commit.
5. Post to Slack and close the loop. The Slack MCP Server posts the same summary to #incident-updates (Figure 2). The incident entity records a triaged_at timestamp through a Port self-service action.

Within a single agent run, the engineer receives a triage summary in Slack that already includes the live Dynatrace signal.

The same Dynatrace integration allows many more use cases, such as deployment correlation, on-call summaries, and postmortem drafts, each built as a Port AI skill.

Security triage works just as easily: ask Port AI about a vulnerability; the Dynatrace MCP Server returns the affected running services, severity, and exposed entities, while Port resolves ownership and routes the fix to the accountable team.

Roll it out across teams, govern centrally

The integration is designed for organization-wide rollout. Admins maintain central control over which tools are exposed and who can access them, while each query remains scoped to the user’s existing permissions.

• Per-tool selection. Admins choose which Dynatrace tools Port AI can call across the organization. Sensitive tools can be scoped to selected groups.
• Per-user authentication. Each user authenticates to Dynatrace through OAuth. Queries return only the data that their existing Dynatrace permissions already allow.
• Audit trail on both sides. Every Port AI call and every Dynatrace MCP call names the same person, with no stitching required between platforms.
• Scales without new workflows. The same per-user model that works for a pilot team works for hundreds of developers. No separate access-request workflow needed.

Get started: connect Port with Dynatrace

The Dynatrace MCP Server connects to Port through a single OAuth flow. Setup takes a few minutes and is done once by an admin.

• Add Dynatrace as a data source. In Port, go to Data Sources > + Data source > MCP Servers. Select Dynatrace, fill in the connector details, and select Connect to authenticate with your Dynatrace tenant.
• Expose the tools you want Port AI to use. Under Allowed Tools, add the Dynatrace capabilities you want available to your organization (querying production data, listing problems, getting problem details, finding troubleshooting guidance). Select Publish.
• Register the incident triage skill. Add the ai-incident-triage skill from Port’s skill library and point it at the incident entities in your catalog.

Once published, the integration is available to every authenticated Port user in your organization. Each user authenticates to Dynatrace individually through OAuth on first use.

For full setup walkthroughs, see Port documentation

Port MCP Connectors documentation: connector setup and admin configuration

Triage incidents with AI: full skill walkthrough

The post Port and Dynatrace: One-prompt incident triage with the Dynatrace MCP Server appeared first on Dynatrace news.

A developer triaging a bug in Jira, or an on-call engineer responding to an alert in Jira Service Management (JSM), can ask their Rovo agent to investigate production issues in Dynatrace using plain language, without leaving Jira or JSM. The Rovo agent answers any relevant questions, calls the appropriate Dynatrace tools, and posts the results back to the Jira workspace. Admins can now complete setup in minutes. Every call runs with the permissions of the requesting user, every action is logged, and data access and cost remain under central control.

Move from “ask the platform team” to “ask the agent”

If your organization uses Dynatrace, much of your production knowledge may reside with the Dynatrace experts on your organization’s platform or SRE team. Everyone else (developers triaging Jira bugs, on-call responders running down JSM alerts, or support engineers handling escalations) either learns enough Dynatrace to investigate production issues on their own or pings the platform team and waits for a response.

The Dynatrace Model Context Protocol Server for Rovo moves this valuable production expertise into the Rovo agent, where it’s accessible to all Rovo users. The Rovo agent holds the Atlassian context (the bug, the alert, the service it relates to) and calls Dynatrace for the production context (problems, topology, root cause). Meanwhile, the developer asking the question gets a usable answer directly in the tool where they’re already working.

How does an on-call engineer use Rovo to triage a JSM alert?

A JSM alert is triggered when a service degradation is detected. The on-call engineer opens the alert’s response panel and asks the Rovo Ops Agent, Atlassian’s built-in AI agent for JSM incident response, to investigate.

Rovo Ops calls the Dynatrace MCP Server, retrieves the open problem, the root cause, and the related signals, and returns a single answer: what went wrong, what’s related, and what to do next. The on-call engineer either acts on this problem context directly or escalates the alert, with the full analysis already attached.

How does a developer triage a Jira bug with Rovo and Dynatrace?

Let’s say Jira provides details of a bug in a service that a developer doesn’t own. The developer asks the Rovo agent a question in the issue’s chat panel: “What’s going on with this service right now?” Rovo returns the open Dynatrace problem, the elevated error rate, and the dependency that’s causing the issue.

Rovo’s answer posts as a comment on the bug in Rovo, so the next person who opens the ticket sees the investigation is already done. From there, the bug typically closes as a duplicate of the active incident or routes to the team that owns the failing deployment, in minutes rather than hours.

How to roll out the Dynatrace MCP Server in Atlassian Rovo

MCP Server setup is a configuration task, not a project. The Dynatrace MCP Server is pre-approved by Atlassian as an external MCP integration and is included with Dynatrace SaaS at no extra cost. In a few clicks, an admin connects Dynatrace using the Rovo admin UI, authenticates against the Dynatrace tenant, and selects which tools to expose. Once connected, the integration is available across Jira, Jira Service Management, and Confluence.

The Dynatrace MCP Server tool set is ready for immediate use, providing data retrieval through Grail, topology and entity context, root cause analysis, active security findings, time-series forecasting, and change-point analysis.

Security, governance, and cost stay under administrator control

Admins keep control over security, governance, audit, and cost on both the Atlassian and Dynatrace sides.

• Per-user enforcement, end-to-end. Every Dynatrace call runs as the requesting user via OAuth 2.1, with authorization based on the user’s Dynatrace permissions. On the Atlassian side, Rovo and Rovo Ops only see the Jira and JSM data that the user is already entitled to see.
• Per-tool selection. From a checklist in the admin panel, administrators choose which Dynatrace tools the Rovo agents in the organization can call. (New tools released later must wait for admin approval before they become available.)
• Audit trail on both sides. Every Rovo invocation and every Dynatrace MCP call names the same person, with no stitching required between platforms.
• Usage and costs are observable in Dynatrace. Tool call volume can be observed with Dynatrace, and costs can be clearly attributed to data owners.
• Adding more Dynatrace users doesn’t increase your cost. Dynatrace consumption is priced on data, not per user, so onboarding more developers and on-call engineers doesn’t instantly impact your billed costs.

Get started with the Dynatrace MCP Server for Rovo now

The integration is generally available. To connect it:

1. In Atlassian Jira or JSM, go to Atlassian Administration → Rovo → Rovo MCP server.
2. Add the Dynatrace MCP Server and authenticate against your Dynatrace tenant.
3. Select the Dynatrace tools you want to expose to your Rovo agents.

Full setup instructions are available in the Atlassian documentation and the Dynatrace MCP Server documentation.

Because the MCP Server is included with Dynatrace SaaS, you can easily set up a pilot program. Just connect the integration for one dev team, allow them access to a narrow set of tools, and then monitor the team’s usage and related costs. The patterns that emerge (which tools are called, by whom, and at what cost) can serve as a basis for a confident wider rollout.

The post Dynatrace MCP Server for Atlassian Rovo: Investigate production problems without leaving Jira or JSM appeared first on Dynatrace news.

Get immediate production visibility inside Claude Code, the next-gen AI coding assistant from Anthropic. The Dynatrace MCP server can now be used as a ready-to-use connector for Claude Code, Cowork, and Chat. Connect in minutes to query logs, traces, and problems; conduct live debugging from your terminal, and validate AI-first workflows with real data.

Model Context Protocol (MCP) is the standard for connecting AI assistants to live tools and data. The Dynatrace MCP server brings your full observability and security context into every Claude session. This means fewer context switches, less time hunting through dashboards, and better answers that are grounded in what’s actually happening in your environment.

How to connect Claude Code with Dynatrace

Getting started is straightforward. Open Claude, go to Connectors, and search for “Dynatrace.” Install the Dynatrace MCP Server connector, follow the setup steps, and you’re connected.

How Dynatrace MCP Server and Claude give you visibility into your production data

Whether you’re investigating a production issue, reviewing a deployment, or working through a security vulnerability, you can ask Claude in plain language and get answers backed by your actual Dynatrace production data. This is not just documentation summaries or generic guidance, but a real window into production.

Troubleshoot without leaving Claude Code

Let’s say you receive a Jira ticket with details of an error. Instead of switching to dashboards and digging through logs to find out what went wrong, you can now ask Claude. Dynatrace pulls all root-cause information, related logs, metrics, traces, and CPU and memory profiling data from your production environment directly into the session. You can query these details by impact, filter by service, and request remediation suggestions, all without knowing in advance where to look or how to write the DQL query.

This same workflow applies when you’re checking for vulnerabilities in your running workloads, verifying whether a recent deployment introduced regressions, or proactively catching performance issues before they hit production.

You can now also use dtctl, the open source CLI for the Dynatrace platform, in Claude Code alongside the Dynatrace MCP server to manage dashboards, run workflows, and execute DQL from your terminal.

The post Bring real-time production insights into Claude Code with the Dynatrace MCP Server appeared first on Dynatrace news.

What is dtctl?

dtctl (short for “Dynatrace control”) is the open-source CLI for the Dynatrace platform; it’s kubectl-inspired, terminal-native, and designed for both AI agents and humans. Platform engineers, SREs, and developers use it to manage workflows, dashboards, queries, and settings from the command line.

With dtctl, AI agents use the same command line interface and commands that your platform engineers, SREs, and developers use to autonomously manage workflows, dashboards, queries, and settings.

Three ways to connect agents to Dynatrace

Dynatrace offers three access patterns for AI agents and automation, all governed by the same IAM permission system. Regardless of which path you choose, an agent can access only the data and operations permitted by its authentication scopes. The right choice depends on your use case; in practice, most teams use more than one approach.

• MCP (Model Context Protocol): A standardized, schema-driven interface in which every tool call is declared upfront and validated automatically. Agents get structured, predictable interactions while platform teams get strict control over which tools are exposed and a full audit trail of every call.
• API: Access to the full platform surface with maximum flexibility. The API is ideal when you need endpoints that higher-level tools can’t cover. The tradeoff: you build and maintain everything yourself, from endpoint selection to token lifecycle, pagination, and rate-limit retries.
• dtctl (CLI): A terminal-native and composable command line interface that’s built for execution speed, with minimal setup: Just run a command, inspect the result, adjust, and repeat. This offers a natural fit for tight iteration loops, scripting, and agents that need to get things done without overhead.

Why is CLI gaining traction for agent workflows?

CLIs have been the primary interface for automation since the early days of Unix, and for good reason. Output is structured, syntax is predictable, and there’s no protocol overhead. MCP mirrors how humans interact with tools and includes discovery, negotiation, and structured handshakes. This is valuable when you need it; however, every schema negotiation round-trip adds tokens and latency to the agent’s context window. CLI skips that entirely and cuts straight to execution.

Use the same CLI tool and commands for human engineers, scripts, and AI agents

Whether you’re a platform engineer or an AI agent, dtctl gives you the same powerful Dynatrace interface. Like kubectl or git, dtctl follows a simple verb-noun syntax: Just state what it is you want to do, then state what you want to act on. What makes dtctl stand out is that it’s designed to support human engineers and AI agents equally.

• A single interface for everything. Workflows, dashboards, notebooks, queries, SLOs, Dynatrace Intelligence, and more, all accessible through the same consistent set of commands. There’s no need to stitch together multiple API endpoints or learn different tools for different resources.
• Built for AI agents. dtctl lets agents discover all available commands at runtime, no documentation needed, no upfront configuration. When running inside an AI agent, dtctl automatically switches to structured output that agents can parse and act on, including follow-up suggestions and error context.
• Built for humans, too. Use tab-autocomplete resource shortcuts like db for dashboards and wf for workflows, –mine to filter your own resources, and an edit command that opens YAML in your $EDITOR and uploads on save. Because dtctl follows familiar command-line patterns, experienced users move fast from day one.
• Managing multiple environments is simple. Switch contexts between dev, staging, and production with a single command. Authenticate via SSO or API token, run dtctl doctor to verify the setup, and you’re ready to go.

For all technical details and the full command reference, visit the dtctl repository on GitHub.

An AI agent modifies a Dynatrace workflow end-to-end

What makes AI agents truly useful is their ability to close the loop: They can discover data, make changes, verify results, and fix what’s broken all without handing control back to a human operator.

Here’s what such a scenario looks like using dtctl. In this example, a Dynatrace workflow queries the number of Kubernetes pods and sends an email report. The goal is to enhance the query so that it lists every pod with its respective node tolerations, making it a cross-entity query that explores the data model, identifies the correct relationships, and iterates until the output is correct.

Using GitHub Copilot in VS Code, the agent works through the full cycle autonomously:

• Discover: Explores the Dynatrace data model to find the right entities and relationships: how pods connect to nodes and where tolerations are stored.
• Iterate: Refines the query step by step until the output matches the goal, then updates the workflow and rebuilds the email report.
• Apply and run: Pushes the updated workflow to Dynatrace and executes it.
• Verify: Checks whether the workflow ran successfully and produced the expected results.
• Fix: If something fails, it reads the error, adjusts the query, and tries again.

The human operator defines only the intent, and the agent handles the rest. Watch this full video walkthrough to see it in action.

Create and modify dashboards without leaving your code editor

One concrete example of what dtctl enables is dashboard creation and management directly from the terminal. Because Dynatrace dashboards are structured data, they can be version-controlled, templated, and automated just like any other code artifact.

To illustrate this, the OpenClaw Gateway Monitoring dashboard shown below was created end‑to‑end in just a few minutes. A developer used GitHub Copilot in VS Code to create an AI observability dashboard similar to others, tailored specifically for monitoring OpenClaw. The agent then pulled existing Dynatrace AI observability dashboards as templates, adapted the layouts and queries to OpenClaw’s monitoring needs, and deployed the results using dtctl; all this was managed by the developer without leaving their IDE.

For day-to-day management, the workflow remains the same, whether executed by an agent or a human: just pull a dashboard, adjust queries or filters, preview the changes, and save the dashbaord. Coding agents can be instructed to update queries across multiple dashboards with a single prompt. And it takes just a single command to promote dashboards from dev to production, or to roll them back instantly if something breaks.

You can take dtctl even further: wire dashboard definitions into your CI/CD pipeline so that, as a service evolves, its dashboards evolve automatically.

Try out dtctl today

dtctl is fully open source and available at dynatrace-oss/dtctl on GitHub, with documentation, skills, and examples to get you started.

Our dtctl Quick Start Guide walks you through the complete setup in under five minutes:

1. Connect dtctl to your environment.
2. Run your first query.
3. Pull a dashboard.
4. Modify the dashboard queries.
5. Save your dashboard.

From there, install the agent skill to teach GitHub Copilot, Claude Code, or Cursor how to operate your Dynatrace environment.

The project is in active development. If you hit a bug or have a use case to share, open a GitHub issue or start a discussion, and help us shape the roadmap.

The post dtctl: The Dynatrace observability CLI that’s built for AI agents and humans appeared first on Dynatrace news.

Unify cloud resources across accounts, regions, and services into a single, real-time dependency graph

As workloads continue to sprawl across AWS, Azure, Google Cloud, and on-premises data centers, teams are overwhelmed by massive volumes of telemetry and constant change. Simple questions like “What service depends on this?” or “Is this vulnerability exposed?” often turn into hours of manual investigation. Smartscape changes this dynamic by unifying every cloud asset, metadata field, and connectivity path into a single, real-time dependency graph, delivering instant answers and visualizing them in a continuously updated Smartscape view. Instead of hopping between AWS and Azure consoles, platform teams finally get a continuously updated picture of how their cloud environments are truly behaving.

With new AWS integrations, Smartscape now also captures deep configuration data, such as VPCs, load balancers, security groups, subnets, network services, and compute metadata, and models these dependencies as native cloud entities. Unlike any other observability vendor, Dynatrace provides full access to the raw observability data in Grail via Dynatrace Query Language (DQL), unlocking powerful exploratory analytics use cases. Each entity includes the complete unprocessed definition of the cloud service as JSON, covering metadata, resources, configuration, security, and networking details, and tags, making this information fully transparent and directly queryable. This unified model delivers immediate customer value:

• Security posture and exposure analysis: detect publicly reachable endpoints, analyze real security group and network policy paths, and prioritize fixes based on true blast radius and reachability.
• IAM hygiene and drift control: uncover risky role sharing across Lambdas, identify configuration drift across accounts and regions, and validate whether access paths reflect intended policy.
• Cost optimization: identify x86 vs ARM workloads, right-size EC2, RDS, and EBS based on real utilization, and connect cloud spend to actual service dependencies to make safer cost decisions.
• Architecture & multi-account visibility: map cross-VPC and cross-region dependencies, unify runtime topology across all cloud accounts, and eliminate hidden or forgotten resources.
• Operational readiness & risk reduction: understand how misconfigurations or outages propagate through infrastructure and into applications, improving impact assessment and response.

The Clouds app provides comprehensive insights and metadata, including metrics and logs for your services, deep insights into resource configurations and cloud topology, and the ability to leverage your cloud tags for access and visibility. With Clouds, teams can interactively explore and analyze their cloud estate, apply segment filters, follow connectivity paths, and compare environments.

Understand your entire setup at a glance through advanced visual analytics

The new Smartscape app’s domain-specific views turn complex, multi-layered cloud estates into something teams can understand instantly. Visual exploration makes it easier to:

• Understand real, observed connectivity between workloads across VPCs and environments, enriched with cloud networking context such as subnets and security constructs.

• Instantly understand problems and their blast radius with affected entities clearly highlighted.

• Identify hidden relationships or unintended dependencies that spreadsheets or lists will never surface.
• Validate migration plans, architectural assumptions, and segmentation strategies before changes go live.

Create a single source of production truth with flexible views and segmentation across cloud dimensions, including tags, accounts, regions, environments, and ownership.

This visual context is often where the “aha” moments happen, the point where teams finally see how their cloud is structured, where risks live, and where optimizations will have the greatest impact.

Utilize DQL for advanced insights customized and enriched with what matters to you

For deeper investigation or automation, DQL lets teams query relationships, join topology with logs and metrics, and run impact assessments programmatically. These queries can be operationalized through dashboards and notebooks. Learn more about how to utilize the new Smartscape DQL commands to query the AWS topology.

Kubernetes: how Smartscape gives you clarity on fast-moving, complex clusters

Kubernetes environments evolve continuously: pods appear and disappear within seconds, configurations drift, and a single missing reference in a YAML file can cascade into service failures across namespaces, or even clusters. While traditional tools expose fragments of this reality, they fall short when teams need complete answers to foundational questions like what does this depend on?, what changed?, or why did this break?

Smartscape further enhances Dynatrace Kubernetes observability by unifying Kubernetes objects, relationships, and configurations across clusters and clouds into a single, real‑time dependency graph. Instead of jumping between kubectl commands, point‑in‑time UIs, and disconnected dashboards, teams gain a continuously updated, system‑level view of how their Kubernetes environments actually behave.

With enhanced ingest, Smartscape now captures all major Kubernetes object types, including ConfigMaps, Secrets, Ingress, PV/PVC, workloads, services, and namespaces, and stores their full YAML definitions and metadata directly in Grail. Teams can query configurations across clusters and clouds, trace live end-to-end dependency paths, and automatically surface misconfigurations, missing references, policy violations, and drift. What was previously scattered across files and tools becomes instantly explorable context, at a global scale. The value of Smartscape can be felt immediately:

• Faster troubleshooting: trace live relationships across clusters, namespaces, workloads, and services to pinpoint drift or misconfigurations that cause runtime failures.
• YAML misconfiguration detection: identify missing references, invalid fields, or policy violations with full YAML-in-context, and regenerate correct configurations using Dynatrace Intelligence.
• Ephemeral awareness: retain visibility into short-lived workload changes or crashes that normally disappear before engineers can inspect them.
• Policy and compliance enforcement: check networking, storage, config maps, resource quotas, and image standards at the object level for stronger governance.
• Safer releases: segment clusters by team or namespace and visualize impact paths before and after deployments to reduce risk and improve deployment confidence.

All enhanced Kubernetes insights and YAML definitions are directly accessible within the Kubernetes app.

In Smartscape, access the Kubernetes domain view, where you can:

• Visualize cluster topology for instant clarity on structure and relationships.
• Follow real dependency chains across namespaces, workloads, services, and underlying infrastructure to understand impact paths.
• Segment clusters dynamically by team, namespace, environment, or workload identity for precise context.
• Isolate critical workloads or namespaces for focused investigation and remediation.
• Validate architectural assumptions by comparing expected versus actual relationships.

For advanced analytics, DQL lets you query Kubernetes objects, relationships, and signals at scale. For actual use cases and examples, check out this notebook on the Dynatrace Playground.

Other domain-specific enhancements, from infrastructure to services

The new Smartscape unlocks a broader range of high-impact use cases across every layer of your IT environment, with topology-enriched information across apps; many new ways to explore your data via DQL, and several additional, use-case-optimized Smartscape views. Below are some additional examples and inspiration to help you get started:

Services

Smartscape now gives you deeper insight into how services connect and communicate in real time. By modeling upstream and downstream dependencies alongside KPIs and infrastructure anchors, Smartscape makes it easier than ever to understand how services interact, where failures originate, and how changes ripple across the stack.

With the new Service Dependency Graph view, teams can instantly visualize their service landscape. The interactive graph makes it easy to follow call flows, isolate a single service and its direct dependencies, highlight performance or error hotspots, and identify unexpected communication paths. Apply your own business context, for example, ownership, to help teams see how services come together to deliver business functionality.

Infrastructure

Smartscape expands visibility into infrastructure by mapping all running components, showing how they’re connected, and identifying how performance issues might impact other critical services. The Infrastructure Overview turns this into an intuitive, navigable map that lets teams focus on the data relevant to them and spot bottlenecks or drift patterns through topology shape. Building on this foundation, upcoming Dynatrace enhancements will allow teams to visually inspect host‑to‑process chains and explore network paths enriched with SNMP/LLDP data.

Problems

Smartscape enhances problem analysis by automatically connecting detected anomalies to the entities and dependencies they impact across your environment. This shows not only what is broken, but how issues propagate across services, workloads, and infrastructure, giving teams immediate clarity on root cause and blast radius. The Problem Graph highlights affected entities, correlates related anomalies, allows for impact isolation, and provides AI-powered insights in context.

End-to-end discovery

The Smartscape app also exposes your entire digital ecosystem as one coherent model, visualizing all dependencies and connecting cloud resources, Kubernetes clusters, infrastructure components, and services end-to-end in the Smartscape on Grail view. This allows teams to understand the real system structure, uncover hidden dependencies, and validate architectural assumptions with complete context rather than piecemeal data.

Experience the new Smartscape today

Smartscape changes how teams operate by providing automatic, real-time context across all domains, enabling faster troubleshooting, safer releases, stronger security posture, and more cost-efficient operations.

• Explore domain-specific views for AWS EC2, Kubernetes, Infrastructure, and Services, with Azure coming soon.
• Run impact analysis with DQL graph queries.
• Combine topology with logs/metrics/traces/RUM for full stack insights.
• Let Dynatrace Intelligence take safe, informed actions based on production truth.

The post The new Dynatrace Smartscape improves operational efficiency across clouds, Kubernetes, infrastructure, and more appeared first on Dynatrace news.

A paradigm shift: Moving from signal monitoring to true entity health understanding

Digital systems continuously evolve and adapt. Making effective decisions requires real-time, always up-to-date insights into how everything is connected—from infrastructure to applications—and understanding the impact on users and the business when issues arise. When an anomaly occurs, you need to quickly pinpoint the root cause, understand why it happened, identify exposed components, and determine which critical services depend on them.

Autonomous AI agents raise expectations for speed, precision, and self-healing IT systems, but, like humans, AI agents rely on high-quality data and rich context to operate effectively. Basic observability signals fall short because they lack contextual information and a holistic view of IT entities and their dependencies, making it difficult to derive impact and causality. In a world of AI agents, an accurate, real-time production context becomes non-negotiable, as only then can you trust AI agents to make the right decisions.

Smartscape has been a core part of the Dynatrace platform for years, and it powers Dynatrace causal AI. Smartscape is a real-time dependency graph that visualizes how your IT components depend on each other, continuously updating as your topology changes. Smartscape maintains AI-ready context across ephemeral components in hybrid and multicloud environments. This real-time discovery and updating happens automatically across multiple sources, so the model always reflects reality and serves as your ultimate single source of truth.

^{Figure 1. Explore your IT systems and their dependencies visually with the new Smartscape app.}

The new Smartscape was developed for cloud native, large-scale environments and comes with major new capabilities:

• Powerful visual analytics in the all-new Smartscape app, including domain-specific views for cloud, Kubernetes, infrastructure, and more.
• Fully native cloud entities with complete metadata and raw cloud/Kubernetes object JSON.
• Agentless cloud data ingest that automatically adds all entity dependencies and policy context.

• Exploration at scale with Dynatrace Query Language (DQL). Run native graph queries (for example, traverse) to multi-hop across millions of relationships with full Grail® context.

These enhancements unlock many high-value use cases, transforming the way you and your teams work.

• End-to-end cloud visibility: Close cloud‑console gaps with full relationship context for faster decisions across multi‑cloud and hybrid environments.
• Understand Kubernetes dependencies immediately: Diagnose issues quicker with full‑fidelity objects, YAML context, and cross‑cluster dependency tracing.
• Stronger security posture: Visualize exposure and attack paths, prioritize by real blast radius, and enforce IAM and configuration best practices.
• Accelerate incident response and collaboration: Use the new Visual Resolution Path to see upstream and downstream dependencies and get Dynatrace Intelligence insights in context. Route alerts to the right owners, cut handoffs, and reduce escalations.
• Validate and optimize architecture and cost: Compare intended vs. runtime architecture, align ownership, and reduce costs using real dependency and utilization context.
• Reliable CMDB/ServiceNow enrichment: Export precise, auto‑discovered dependencies with external IDs for accurate ITSM automation.

Spot and understand patterns instantly with the new Smartscape app’s powerful visual analytics capabilities

The new Smartscape app delivers rich, large-scale visual analysis tailored for modern cloud and AI-native environments, with a smooth and responsive experience at scale.

• Explore thousands of entities interactively and quickly drill down into topology and entity details.
• Navigate your entire environment with all dependencies, or use domain-focused, ready-made Smartscape views for clouds, Kubernetes, classic infrastructure, or services.
• Work in context across the platform:
  • The Visual Resolution Path in the Problems app lets you jump directly into the Smartscape Problems Graph to analyze systemic patterns or blast radius.
  • View topology: an intuitive, in-context action that lets you explore vertical and horizontal topologies for any entity without leaving your app or workflow, which is perfect for understanding dependencies and drilling into details.
• Align views to your business context with segments. Focus your analysis on entities by team ownership, environment, business unit, or region to reduce noise during change windows and reviews. This allows you to understand who owns what and accelerate collaboration with a shared understanding of your IT system.
• Analyze patterns from every angle: switch topology layouts to reveal different insights. force exposes hidden clusters and dependency hubs for dynamic microservice exploration; horizontal traces workflows left to right for end-to-end transactions or CI/CD flows; and vertical highlights layered architectures top to bottom for dependency stacks or escalation paths.

Agentless topology discovery from clouds

Dynatrace can now directly discover entities and relationships from cloud environments, including security groups, VPCs, load balancers, subnets, and other network services, providing accurate connectivity, policy, and configuration context, even without deploying OneAgent. In addition to raw topology, Dynatrace automatically ingests, normalizes, and enriches cloud‑native metadata such as tags, labels, ownership properties, cost centers, compliance attributes, and compute metadata, creating a high-quality semantic layer.

All discovered entities and their metadata are unified in the new Smartscape, revealing practical and actionable insights, for example: Which instances are publicly accessible? How is traffic routed across accounts and regions? How do security groups influence exposure paths? And much more.

Experience the new Smartscape, now Generally Available, in your Dynatrace environment

Explore the new Smartscape app, which will be available in your Dynatrace SaaS environments during the first week of February 2026, and begin uncovering dependencies across clouds, Kubernetes, infrastructure, services, and problems.

For a deeper dive, check out our documentation and walk through the Playground notebook, which guides you step‑by‑step in using DQL to query Kubernetes entities.

And stay tuned: our next blog post in this series will take you even further, exploring the new domain‑specific views in Smartscape.

Ready to get started? Start exploring your digital systems now on the Dynatrace Playground.

The post The new Smartscape: Move faster and make better decisions with a real-time dependency graph of all your digital systems appeared first on Dynatrace news.

Spark continuous improvement by making data exploration a habit

In practice, exploration often stalls. Logs live in one tool, metrics in another, traces somewhere else, and the broader business context lives with different teams. Answering a single question, such as “Did this pattern exist before the last release?” can mean switching contexts, running separate queries, and manually correlating results. The friction builds, and a deeper investigation is deferred until the next incident forces it.

There is more than one kind of exploration. Sometimes exploration is structured: embedded within workflows as part of postmortems, release validations, or SLO reviews, tracing signals across logs, metrics, traces, events, and business data to link impact to outcomes and prevent repeat failures. Other times, exploration is curiosity-driven: a quieter moment where you notice a memory pattern tied to a batch job, a timeout spike with specific clients, or a cloud spend anomaly you’d never have caught in a scheduled report.

Both of these exploration modes matter. Together, they foster learning and a culture of continuous improvement, both essential to modern enterprises.

Dynatrace Grail, a unified data lakehouse, makes exploration easy and rewarding: a single place for all your live production data across logs, metrics, traces, events, business, and security data, so you can follow the evidence wherever it leads without rigid queries or manual joins. With Dynatrace Query Language (DQL), every field and relationship is at your fingertips, enabling broad searches, contextual pivots, precise slicing, and rapid iteration to test and discard weak hypotheses.

Dynatrace Intelligence® makes exploration accessible to everyone. Use Assist to query and explore your data in natural language, or get support in interpreting and understanding your findings. Leverage AI-powered analysis to detect patterns and anomalies at scale, or forecast trends to predict future behavior.

To support different exploration needs, Dynatrace offers a portfolio of use-case optimized apps:

• Dashboards for persistent, shared visibility and ongoing monitoring.
• Smartscape for visual analytics of real-time topology and dependency context.
• Notebooks for collaborative, ad hoc exploration and rapid hypothesis testing.
• Investigations for sequential, forensic depth in complex scenarios.

Move seamlessly between apps without losing context. Start in Dashboards, drill into a data point, and continue to explore your data in Notebooks. From there, you might run a deep, focused analysis in Investigations, then pivot to Smartscape for a dependency graph. Finally, bring your findings back into a dashboard for continuous monitoring, making your entire exploration journey seamless.

Let’s look at the apps in more detail, starting with Dashboards, often a natural entry point for your exploration journey.

Dashboards: from real-time visualizations to taking action

Dashboards provide a powerful way to transform complex data visualizations into actionable insights, serving as the cornerstone of the Dynatrace exploratory analytics portfolio where exploration meets operational excellence. By offering real-time visibility into key metrics, dashboards help teams monitor performance, identify trends, and make informed decisions. With ready-made dashboards for common use cases, such as Kubernetes, infrastructure, and digital experience monitoring, teams gain immediate access to critical insights, allowing for faster and more proactive responses to their daily challenges.

Dashboards are designed to foster operational clarity with intuitive, interactive visualizations that allow you to drill down into metrics, apply filters, and segment data to uncover meaningful patterns. While Notebooks and Investigations are ideal for deep dives and custom analyses, Dashboards deliver concise, shareable, real-time views that keep teams aligned and informed.

Deeply integrated with Dynatrace’s AI-powered analytics, dashboards enhance visualizations with contextual explanations, anomaly detection, and forecasting. These capabilities allow teams not only to monitor what’s happening but also to understand why it’s happening and predict what might happen next. By making insights accessible to both technical and non-technical stakeholders, dashboards foster collaboration, break down silos, and empower teams to stay aligned and proactive.

Use Dashboards to:

• Monitor KPIs and SLOs in real time
• Identify anomalies and emerging trends early
• Align teams with shared, role-based views and a single source of truth
• Trigger deeper analysis via drill-downs into charts and entities
• Track progress against goals and initiatives over time
• Surface business and technical context side by side for informed decisions

Smartscape: visualize the topology and dependencies of your complete digital systems

Smartscape® is the latest addition to the Dynatrace exploratory analytics app portfolio, and it’s a game-changer for exploring highly dynamic IT systems. Purpose-built for real-time visual analytics, Smartscape gives you a dynamic, interactive view of your entire IT ecosystem—spanning all layers, including services, cloud, Kubernetes, and on-premises infrastructure. Unlike static diagrams or manual dependency maps, Smartscape updates continuously, so you can understand changes as they happen.

Smartscape’s visual analytics capabilities go far beyond simple mapping. It provides multidimensional, domain-specific views that allow teams to see how services, processes, and infrastructure interact in real time. This real-time visualization helps uncover hidden dependencies, assess the blast radius of outages, spot drift or misconfigurations, and validate architecture after deployments. Apply your business context by using Segments, and pivot from other apps like Problems, Kubernetes, or Clouds into Smartscape without losing context.

Use Smartscape to:

• Visualize real-time dependencies and communication paths across services and infrastructure
• Assess blast radius and map out highly connected and interdependent entities during incidents
• Validate architecture and changes after deployment
• Identify and understand hotspots, bottlenecks, and hidden dependencies
• Navigate readymade domain views for clouds, Kubernetes, services, and infrastructure with zero setup
• Align engineering, ops, and business teams with a shared, always-current understanding

Notebooks: collaborate, explore, and solve problems in real-time

Notebooks bridge the gap between the two modes of exploration and play an important role in both standardized processes and curiosity-driven exploration.

As a workspace for free exploration, Notebooks give you a playground to experiment with data, quickly visualize insights with a large set of chart types from a curated library, and iterate quickly. You can slice massive datasets in real time, pivot on context, and uncover patterns without constraints.

At the same time, Notebooks shine in collaborative workflows. Teams can work together to document and share findings during incident resolution or postmortems, create troubleshooting guides, and also generate automated reports from queries, all within the same space. Notebooks documenting incidents are automatically surfaced in the Problems app via vector search when similar issues occur, and snapshots of investigations can be preserved as long as needed outside of retention period settings, ensuring insights remain accessible.

Whether you’re just performing free-form discovery or creating documents within processes, Notebooks make it effortless to turn exploration into reusable assets.

Use Notebooks to:

• Collaborate on incident investigations
• Document postmortems for future reference
• Report insights ad hoc or on a schedule
• Analyze your data using generative AI
• Prototype and validate DQL for alerts, workflows, and automation
• Tell data stories with rich visuals and narrative
• Build a reusable knowledge base to reduce MTTR
• Extract data on demand
• Transform and shape data on read

Investigations: dive deeper with sequential analysis and forensics

When exploration moves from curiosity to critical analysis, Investigations is your go-to tool. Built for structured, forensic deep dives, it’s the perfect complement to ad hoc exploration in Notebooks.

Investigations works with DQL across all data in Grail, including logs, events, metrics, traces, business data, and security signals. Teams can pivot from initial findings to comprehensive analysis without friction, comparing scenarios and following evidence trails wherever they lead. The query tree tracks your analytical path, letting you branch into parallel hypotheses and return to previous queries and results at any point.

Imagine this flow: a security team is alerted to unusual login attempts or wants to follow up on an anomaly spotted in Dashboards or Notebooks. With a single click, they transition to Investigations to trace lateral movement, simulate attack scenarios, and preserve evidence for future reference. Investigations support sequential workflows, allowing you to pivot queries based on metadata, visualize intricate patterns, and even enrich analysis with lookup tables and external data joins.

Pivot queries based on metadata, visualize patterns across multiple dimensions, and enrich your analysis with lookup tables and external data joins. Because all Grail data is accessible, you can seamlessly connect the dots, linking a suspicious error to its pod’s resource consumption, or tracing a payment failure back to the infrastructure event that caused it. Custom pivots let you select multiple findings and branch into separate queries automatically.

When you’ve found what you’re looking for, save the investigation, or just the relevant branches, as a Notebook to share with your team.

This isn’t just incident response, but everyday analytics for complex environments. Investigations help teams validate hypotheses, document findings, and strengthen resilience across IT systems.

Use Investigations to:

• Conduct structured, multi-step analyses across services and systems
• Correlate signals from applications, infrastructure, and user activity
• Follow evidence trails to confirm or refute hypotheses
• Explore parallel scenarios with branching query paths
• Diagnose complex integration and dependency issues across environments
• Collect and preserve evidence for auditability and knowledge reuse
• Enrich analyses with context (for example, lookups, reputation data, metadata)

Ready to make more of your data with Dynatrace?

Chances are your IT organization is currently focused on increasing efficiency, strengthening resilience and security, increasing agility, or aligning more closely with business priorities. Within your Dynatrace data, there are likely far more insights waiting to be uncovered, helping you accelerate these goals. Start by formulating the right questions: Where are inefficiencies hiding? Which patterns precede incidents and impact uptime? How exposed are critical services?

Give yourself time and room to explore: Visualize dependencies in Smartscape. Use Assist to turn your questions into DQL queries in Notebooks; experiment and try things out. When findings require structured follow-up, Investigations will help you get a complete understanding. And finally, for anything interesting you see on a chart, dashboards let you drill down into the details.

Start exploring now and make exploration a cornerstone of continuous improvement.

For inspiration and an overview of available Exploratory Analytics resources, take a look at our Perform 2026 – Exploratory Analytics Launchpad.

The post Explore without friction: Deeper insights with Dynatrace expanded analytics app portfolio appeared first on Dynatrace news.

The whole industry is using and adopting agentic AI. In fact, AI agents are only as effective as the data that powers them. Whether supporting developers through code assistants, accelerating ITSM workflows, automating cloud operations, or enhancing threat detection, you need high-quality data with full context awareness. Only this allows AI to be a trusted and effective partner, delivering reliable recommendations based on a deterministic foundation. The Dynatrace MCP Server, as part of Dynatrace Intelligence, allows AI assistants to interact with Dynatrace and access live, context-rich observability data and reliable AI-insights for smarter, autonomous operations.

Get real-time insights from your digital systems right inside your processes

In traditional IT monitoring, fragmented data and manual tagging were inconvenient. In an AI-native world, they’re a fundamental flaw. AI systems built on incomplete or disconnected data can’t make informed decisions, leading to unreliable recommendations or, even worse, unreliable autonomous action—a scenario that keeps executives on edge.

Dynatrace Intelligence, the agentic operations system built into the Dynatrace platform, solves this with a real-time, deterministic, and context-rich understanding of your entire digital systems.

The Dynatrace MCP Server, as part of Dynatrace Intelligence, provides a secure and governed interface that allows your AI ecosystem to interact with the Dynatrace platform and access data and findings powered by Dynatrace Intelligence. It uses the Model Context Protocol (MCP), an open standard that defines and handles safe interactions between agents, external data sources, and tools.

Together, Grail and Smartscape provide the technical foundation for Dynatrace Intelligence to let agentic AI act on facts, not guesses, ensuring that AI-powered decisions are accurate, scalable, and actionable, a prerequisite for reliable autonomous operations.

By exposing Dynatrace’s unique capabilities, the MCP Server delivers trustworthy, real-time knowledge directly into agentic workflows. This includes:

• Contextualized signals with a holistic understanding of every data point within its full operational and business context, provided by Grail, Dynatrace’s AI-optimized, unified data lakehouse.
• Real‑time topology and causal dependencies, powered by Smartscape, a real-time dependency graph that reveals how systems, services, and cloud components relate and influence one another.
• Deterministic, causal‑AI‑driven root‑cause analysis with correlation to real business impact.

Empower your AI agents to deliver greater value through live production data

You can connect Dynatrace to any MCP client in minutes: no server to deploy, install, host, or maintain. Use the Dynatrace MCP Server to accelerate integration and ensure a smooth transition from pilot to enterprise-scale adoption.

Through the tools hosted on the Dynatrace MCP Server, you can use natural language to query all your data on Grail, check system health, and get problem analyses and remediation recommendations. This allows seamless access to production insights across the applications you already use, including your IDE, Microsoft Copilot, Slack, and automation platforms like n8n. The MCP Server powers numerous more integrations: Azure SRE, AWS DevOps, GitHub Copilot, Atlassian Rovo Ops, AWS DevOps Agent, Kiro, and Amazon Q, to name just a few.

For customers exploring their own tailored solutions, the community-driven local MCP Server is also available. It already sees wide adoption as a flexible way to experiment with new use cases, adapting the MCP to specific needs, and prototyping ideas before moving them into production.

Where the MCP Server delivers value

The Dynatrace MCP Server brings production truth directly into development, operations, ITSM, and business workflows, allowing AI assistants to reason, decide, and act with full contextual awareness. Examples include:

• Development workflows: In-IDE access to live production signals, root causes, exceptions, impacts, and even code-level stack traces, for example, GitHub Copilot querying Dynatrace data in natural language to validate changes and accelerate fixes, with no tool switching required.
• Operations & SRE: Real-time context for accelerated triage, proactive remediation, and evidence-rich postmortems, for example, the Azure SRE Agent integrates with the MCP Server to diagnose anomalies and trigger automated responses.
• ITSM & Incident Management: Enriched tickets with topology, dependencies, business impact, and AI-driven recommendations, for example, Atlassian Rovo Ops delivers end-to-end, context-aware incident management.
• Business Intelligence: Live production insights for product, sales, support, and process teams to link system behavior to customer and business outcomes, provided through MCP clients like Slack, Microsoft Copilot, or ChatGPT.

The Dynatrace MCP Server is now generally available

Dynatrace Intelligence provides insights grounded in real-time topology, deterministic causal analysis, and deep semantic understanding of your environments. Every recommendation is rooted in precise, explainable, and actionable production truth, giving AI systems the reliable foundation they need to operate safely and autonomously.

The Dynatrace MCP Server brings contextualized observability data and insights from Dynatrace Intelligence directly into your broader AI ecosystem.

Connect Dynatrace to any MCP client and start using it in minutes.

You can work with widely available MCP clients such as Microsoft Copilot or ChatGPT, integrate the Dynatrace MCP Server into your ITSM and incident management workflows through ServiceNow or Atlassian Rovo, bring production context directly into VS Code or other IDEs, or orchestrate automated actions through workflow tools like n8n or Copilot Studio.

Explore real-world examples in our latest blog post on the AI ecosystem, or explore all Dynatrace AI ecosystem-related announcements.

For details on configuring the Dynatrace MCP Server, go to our documentation.

The post Dynatrace MCP Server: Empower your AI assistants to interact with Dynatrace and access live production insights appeared first on Dynatrace news.

March 31, 2026 update

Today we congratulate AWS on the general availability of AWS DevOps Agent. This marks an important step forward in how teams operate and innovate in the cloud, moving closer to systems that can investigate and respond with minimal human intervention.

At Dynatrace, we are proud to have collaborated with AWS on this initiative from the beginning. Together, we have worked to bring observability, AI, and automation closer together to help customers simplify operations and resolve incidents faster.
Our joint customers are already seeing measurable value, including up to a 70 percent reduction in mean time to resolution, as teams move from reactive troubleshooting to more intelligent and automated workflows.

This work reflects a broader shift toward agentic operations. We are continuing to deepen our collaboration with AWS across DevOps Agent and other AI services as this space evolves. This foundation sets the stage for how the Dynatrace platform and AWS DevOps Agent integration works in practice.

How AWS DevOps Agent and Dynatrace complement each other to resolve incidents faster

It’s late at night, you’re on call, and an alert fires for an AWS application. You need to assess the severity, understand the impact, and quickly notify the relevant teams. Until now, that potentially meant toggling between Dynatrace and the AWS Console to piece together the full picture. With the AWS DevOps Agent and Dynatrace integration, you instantly have all the information you need at every stage of remediation.

AWS DevOps Agent represents a new class of frontier agents: AI that works autonomously for hours or days, investigating incidents without constant human intervention. Dynatrace provides causal and predictive AI that pinpoints the root cause of issues and anticipates problems before they escalate. Together, they create something neither can deliver alone: end-to-end incident resolution that spans from early warning through root cause to remediation.

When AWS announced the DevOps Agent at re:Invent last December, they showcased this integration as a key use case, demonstrating how autonomous investigation becomes dramatically more effective when powered by Dynatrace precise, topology-aware production context. The agent doesn’t just correlate signals; it understands what those signals mean for your business.

Experience topology-aware root cause analysis with guided mitigation

Consider a typical CRM stack: a React frontend on S3 and CloudFront, an ALB routing to Lambda-hosted Python services implementing the CRM business logic, backed by an RDS PostgreSQL. During normal operations, the responses take ~1 ms, but suddenly those degrade to 1 s+. Dynatrace instantly detects the problem with all relevant context, including business impact, and automatically triggers the AWS DevOps Agent to initiate further investigation.

Figure 1: Dynatrace and the AWS DevOps Agent work hand in hand to analyze and mitigate the problem.

• Root cause analysis with causal AI: Dynatrace detects response-time degradation and automatically gathers relevant context, including potentially AWS resources causing the issue, such as Lambda, RDS, and ALB.
• Seamless collaboration with AWS DevOps Agent: Dynatrace triggers the AWS DevOps Agent and passes full runtime context, allowing it to trace the execution path from symptom to failing component.
• Pinpoint the root cause: The AWS DevOps Agent analyzes underlying RDS logs, identifies DROP INDEX commands that correlate with slowdown events, and surfaces the findings directly in Dynatrace, without tool switching. The commands are traced to an input error by a database administrator.
• Recommend and stage a fix: the agent provides a clear diagnosis, recommended remediation steps, and proposed action that’s ready for human approval.
• Prevent recurrence: The agent suggests proactive monitoring of database logs for similar commands to prevent future incidents.

This always-on, on-call workflow accelerates triage, allows topology-aware root cause analysis, guides mitigation, and adds preventative recommendations. It works across a broad set of AWS services, including AWS Lambda function errors, Amazon EKS container failures, Amazon VPC connectivity issues, and more.

Ready to try it out yourself?

With the Dynatrace integration into AWS DevOps agents, you get:

• Fewer handoffs and clearer ownership with a single investigation narrative (no bouncing between teams/tools)
• Less manual correlation as Dynatrace supplies topology, dependencies, and traces as a ready-to-use production context
• Faster “why” analysis as AWS DevOps Agent correlates AWS telemetry with change/deployment history and proposes mitigations
• A more repeatable incident response, including prevention recommendations to reduce repeats

For more details on the preview and how to try it yourself, have a look at this hands-on walkthrough on the AWS Cloud Operations Blog. You can also refer to AWS documentation for instructions on connecting Dynatrace and the AWS DevOps Agent.

For more news on Dynatrace and AWS, have a look at this recent blog post.

The post Integration with AWS DevOps Agent: Autonomous investigations powered by production context appeared first on Dynatrace news.

The integration of Dynatrace with Microsoft Azure SRE Agent establishes a new benchmark for cloud operations by leveraging AI-based root cause analysis and real-time production insights, alongside a comprehensive understanding of complex, large-scale IT environments. You can leverage the combined strengths of Dynatrace and Microsoft, enabling teams to resolve complex problems in large-scale IT environments more quickly and efficiently, and automate incident remediation, moving one step closer to driving autonomous operations across their complex environments.

In today’s cloud-first world, reliability isn’t just a goal; it’s a competitive advantage. As more services move online and LLM-powered assistants evolve into autonomous agents, maintaining the reliability, scalability, and cost-efficiency of critical systems becomes essential.

That’s why Dynatrace and Microsoft teamed up to integrate Dynatrace® AI-powered observability with the Azure SRE Agent. This collaboration allows site reliability engineers (SREs) to ensure seamless operations while proactively planning for future scalability and reliability requirements.

Transform your incident management through the combined capabilities of Azure SRE Agent and Dynatrace AI

Azure SRE Agent, introduced earlier this year, provides SREs and developers with the tools they need to increase the speed and efficiency of incident responses, diagnostics, and collaboration, allowing them to resolve problems quickly.

Seamlessly integrated with incident management tools such as ServiceNow, as well as the developer ecosystem, represented by GitHub Copilot or Azure DevOps, the agent runs in the background 24/7, learning and monitoring the health and performance of your cloud environment.

As a reliability assistant, Azure SRE Agent supports teams by efficiently diagnosing and resolving production issues. You can ask the agent questions in natural language, easily access clear and concise problem summaries, and coordinate incident workflows with integrated human-in-the-loop approvals.

Dynatrace enhances Azure SRE Agent’s troubleshooting and automation capabilities with advanced observability insights. By mapping topology, data, and business context, Dynatrace gains a comprehensive understanding and delivers production-accurate visibility across your entire IT system. This visibility feeds Dynatrace deterministic AI, allowing precise root-cause identification and impact analysis. All these insights are now seamlessly supplied to the Azure SRE Agent, equipping it with real-time production context and reliable root cause analysis.

This allows your teams to move beyond simply receiving alerts; teams are now provided with AI that acts, guides safe mitigations, and accelerates resolution within Azure-native workflows.

Gain efficiency across every stage of the incident lifecycle

Using the Model Context Protocol (MCP), the Azure SRE Agent is securely connected with Dynatrace. Whether a team member uses the agent to ask questions in plain natural language, or the agent interacts with Dynatrace directly—sharing insights, asking for real-time observability data, or root cause analysis, together with remediation steps—the close collaboration supports use cases across every stage of incident management, allowing you to:

• Cut MTTR by automating routine runbooks and diagnostics, with safe, approved mitigation actions based on full context.
• Reduce security risk by triaging vulnerabilities faster with production evidence, triggering guided fixes, and validating outcomes.
• Accelerate delivery with contextual GitHub issues and PRs that include root cause, blast radius, and tests, minimizing issue reproduction time and rework.
• Improve fix accuracy by correlating Azure and Dynatrace telemetry for precise root-cause and impact analysis.
• Prevent incidents before they happen using real-time signals and historical trends to stop regressions and reduce toil.

Illustrating the value: Proactively detect and remediate security vulnerabilities

Let’s take a look at a concrete example, which we presented at Microsoft Ignite. Imagine you run a Java-based payroll app on Azure, and a new security warning (CVE) appears. Every second matters now, and there’s no room for error: you need the issue fixed quickly, without lots of back-and-forth between teams.

• Once the vulnerability is detected, Dynatrace automatically identifies the library that caused the vulnerability, opens a GitHub issue containing all relevant information, such as which parts of your app are affected, and informs Azure SRE Agent.
• The SRE agent reviews the GitHub issue and requests additional information from Dynatrace via the MCP server, such as the number of users affected, how often it happens, which endpoints are involved, or which customers might be affected, to assess the scope and impact of the vulnerability.

• After gathering all necessary details, the SRE Agent synthesizes the information and creates a new GitHub issue, assigning it to GitHub Copilot for remediation.
• GitHub Copilot then takes action by updating the configuration and code in the GitHub repository to resolve the vulnerability automatically.
• The pull request not only includes the necessary version changes but also includes documentation, highlighting all findings as well as how the issue was remediated, along with unit tests, to prevent the issue from recurring.

Try the power of Agentic AI for incident resolution

Dynatrace delivers deep, causation-based insights into your live systems, now seamlessly integrated with Azure SRE Agent to elevate your incident management. With this integration, you can unlock:

• Smarter detection and remediation: Deep contextual observability from Dynatrace, correlated with Azure telemetry, enhances issue identification and resolution across complex environments.
• Automated operations: Routine runbook actions and diagnostic workflows can be automated, reducing mean time to repair and freeing teams to focus on innovation.
• Proactive reliability: Continuous analysis of real-time and historical data identifies leading indicators of failure, allowing teams to prevent incidents before they impact customers.

Azure customers can now access Azure SRE Agent directly in the Azure portal. To connect Dynatrace with the agent and learn how to set up Dynatrace MCP Server, see Dynatrace Documentation.

The post Boost cloud reliability: Dynatrace and Azure SRE Agent unite for autonomous operations appeared first on Dynatrace news.

Ninety-five percent of Generative AI projects fail to deliver measurable value, and leaders are under mounting pressure to demonstrate that their AI investments are effective. Achieving this requires clear visibility into how and where AI is used, and the outcomes it’s driving.

Dynatrace is setting a standard for observability across the AI stack, and we’re extending that same level of insight to our own AI tools. The new Davis CoPilot® Feature Adoption Dashboard utilizes the same telemetry that Dynatrace teams rely on to improve product quality. Assess effectiveness and optimize how Davis CoPilot supports productivity and decision-making, to move from experimentation to sustainable results.

Davis CoPilot, the Dynatrace platform’s LLM-powered assistant, helps teams work faster by leveraging the full context of their data on Dynatrace to deliver precise and actionable answers. The result is less time spent searching for information or onboarding users, and more time extracting the maximum value from the Dynatrace platform and achieving measurable outcomes.

IT and central team leaders typically offer Davis CoPilot to their users, with specific goals in mind that align with their organization’s broader AI strategy. Initiatives like these typically aim to achieve three key objectives:

• Adoption and engagement: Ensure AI becomes an integral part of routine workflows, so value can scale across teams.
• Productivity gains: Reduce manual effort, increase speed to insight, and improve the quality of outcomes.
• Demonstrable business value: Connect usage to measurable results, such as reduced operational costs, faster incident resolution, or improved service levels.

Understand how AI is used and how it delivers value

To make these objectives measurable, you need visibility into how AI is adopted by your users, the purposes it serves, and whether it delivers the intended value. Only then can you identify where improvements are needed. The ready-made Davis CoPilot Feature Adoption Dashboard delivers this visibility out of the box, showing how Dynatrace generative AI features are used across your organization. Based on the provided metrics and insights, administrators and central teams can make data-driven adjustments.

Know how frequently and for what purpose Davis CoPilot is used, in real time

Gain real-time visibility into when and how regularly teams are using Davis CoPilot in their workflows. The dashboard highlights active engagement, query activity, and usage trends across your organization, helping you understand where Davis CoPilot delivers the most value and where additional enablement may be needed.

By analyzing usage patterns, you can identify high-performing teams, monitor overall adoption progress, and ensure employees are using Davis CoPilot effectively to achieve meaningful outcomes.

For a deeper analysis, break Davis CoPilot usage down further by skill:

• Chat: Analyze chat interactions and workflow actions (currently in private preview), showing how users engage with Davis CoPilot to ask questions, troubleshoot issues, and automate routine tasks.
• Natural language querying: Tracks how users convert everyday language into Dynatrace Query Language (DQL) commands, supporting faster data exploration for both technical and non-technical users.
• Explain DQL queries: Shows how users rely on Davis CoPilot to interpret and summarize complex queries, making it easier to understand and build on existing work.
• Document search: Tracks how users engage with AI-driven document retrieval for accelerated troubleshooting in the Problems app.

Track user experience and satisfaction

To determine whether Davis CoPilot delivers value, it’s important to measure not only usage but also the quality of user interactions and outcomes. The dashboard tracks execution times and success rates to demonstrate how well Davis CoPilot performs in real-world scenarios. This makes it easier to identify technical issues such as invalid DQL generation or prompts blocked by guardrails and content filters.

Additional user feedback adds context to these signals. Thumbs-up and thumbs-down reactions help indicate where users achieve the desired outcome and where they run into problems. When negative feedback clusters around similar prompts or skills, administrators can examine the failed prompts, identify common failure modes, and understand the conditions that lead to them. This supports targeted follow-up actions, such as improving internal guidance for AI usage, reinforcing enablement for specific teams, and surfacing actionable improvement requests to Dynatrace.

For example, if multiple users struggle with natural language queries for Kubernetes data, admins can review the failed prompts, provide best practices, and verify that these measures lead to higher success rates over time. You can even consider enriching your data by adding common synonyms with OpenPipeline. Nequi shared their story at Perform 2025.

Together, operational metrics and contextual feedback help organizations to quickly identify friction points and take concrete steps to improve user outcomes and overall satisfaction.

Optimize performance of AI-generated insights

The dashboard also provides transparency into the queries executed through Davis CoPilot, including query counts and the volume of data scanned. This helps you better understand the resource and cost impact of AI-generated insights across your environment. This level of visibility is critical, as many AI initiatives stall because teams lack the insight to understand the operational impact of increased usage.

By identifying data-intensive queries early, you can optimize performance, control cost exposure, and avoid unexpected resource spikes that can undermine confidence in scaling AI. Capabilities such as segment filtering or organizing data into dedicated buckets allow you to fine-tune data access based on organizational needs. This gives you the ability not only to monitor AI activity but also to adjust and govern it responsibly, ensuring Davis CoPilot remains efficient, controlled, and aligned with your broader business objectives.

Make use of the full potential of Davis CoPilot

The Davis CoPilot Feature Adoption Dashboard equips you with the insights needed to scale Davis CoPilot responsibly, maximizing productivity gains while maintaining control. With clear visibility into usage, success rates, and operational impact, you can build a stronger foundation for continued AI expansion.

The dashboard is instantly available in the environments of Dynatrace customers who have enabled Davis CoPilot.

The post Enhance the impact of Dynatrace Davis CoPilot with built-in observability appeared first on Dynatrace news.

Dynatrace Query Language (DQL) delivers unlimited contextual analytics, but if you’re not writing queries every day, the learning curve can feel steep. Davis CoPilot® makes things easier by generating even complex DQL queries from natural language alone. With its latest enhancement, Davis CoPilot can also summarize and explain existing queries in context, showing what a query does, why it’s structured the way it is, and how the results relate to the underlying data. This helps teams validate intent, spot gaps, and confidently build on each other’s work without requiring deep query expertise.

Suppose you’ve opened a dashboard or notebook and found a complex query you didn’t write. You know the struggle: queries can be overwhelming to look at, key details may be nested or referenced elsewhere, and you might not be familiar with the specific data syntax or the user’s original intent. Even revisiting your own work after a few weeks can mean trying to remember what the dashboard was designed to show and how the query fits together. Reverse-engineering shouldn’t be a prerequisite for collaboration.

With the Summarize and explain queries Davis CoPilot skill, you get a clear, contextual explanation of any query, helping you quickly understand what it does.

Figure 1. Get an explanation of any DQL query. (video)

From creating queries to explaining them

Last year, we introduced natural language querying, allowing anyone to explore their data without learning DQL syntax. Now, Davis CoPilot can also interpret existing queries using the Dynatrace data model, explaining what the query does, how it filters and calculates results, and which data sources it uses. This reduces the effort required to work with complex syntax, facilitating the onboarding of new users while enabling experts to validate intent and iterate more efficiently.

The Explain and summarize queries skill is available in Notebooks and Dashboards. Review queries from teammates, tailor ready-made dashboards to your specific needs, and accelerate knowledge sharing.

Try it out on the Dynatrace Playground

Dynatrace offers a wide range of ready-made dashboards to help you get started instantly; however, sometimes you need to tailor dashboards to your unique use cases. With the Explain and summarize queries skill, you can instantly understand how the underlying queries were built by Dynatrace experts, giving you guidance and inspiration for your own customizations. See the examples below:

Log ingest overview dashboard: The table below highlights your noisiest log sources, helping you quickly pinpoint where excessive volume might be driving up ingest costs or masking real issues. With Davis CoPilot, you can see exactly how the underlying query is constructed, making it easy to extend the logic or use it as a template for your own ranking and cost-optimization dashboards.

^{Figure 2. Davis CoPilot explains a query of the top 20 log producers in your system.}

Databases overview dashboard: The following chart identifies slow or inefficient SQL statements that degrade application responsiveness, allowing you to focus your tuning efforts where they matter most. Use Davis CoPilot to break down the logic behind the analysis so you can adapt its scope, filter for critical services, or enrich results with additional business context.

^{Figure 3. Davis CoPilot explains a query that identifies the 20 most resource-intensive statements from Oracle databases.}

Kubernetes cluster dashboard: Optimizing Kubernetes requires clear visibility into how workloads consume cluster resources. This query returns CPU usage broken down by namespace, helping you detect saturation early and maintain efficiency. With Davis CoPilot, you can see exactly how the query works and then adapt it to create your own capacity-planning tool.

^{Figure 4. Davis CoPilot explains a query returning CPU quotas per Kubernetes namespace.}

Ready to try it out yourself?

This feature is already available in all environments; you just need to ensure that Davis CoPilot is turned on and that you have the necessary permissions for this skill. Learn more about Davis CoPilot summarization and explanation of DQL queries in Dynatrace Documentation.

The post Understand and validate DQL queries using Dynatrace Davis CoPilot appeared first on Dynatrace news.

The new Dynatrace integration with Atlassian solves this by embedding real-time production insights directly into incident management processes. Teams gain instant visibility into what’s happening, who’s impacted, and the actions required to resolve issues faster — all without the need to switch tools.

Dynatrace uniquely detects problems in real time by understanding topology, data context, and dependencies across your entire digital ecosystem. Incidents are automatically tied to underlying root causes, giving teams a complete, production-accurate, “live” picture of problem details, severity, and impact.

Dynatrace insights are now accessible in Jira Service Management through human-readable summaries generated by Atlassian Rovo. By bringing production context directly into Jira, Confluence, and Jira Service Management, you’ll accelerate response times and significantly reduce mean time to resolution (MTTR).

At Dynatrace, context is our mantra, sitting at the core of everything we do. This means more than just data enrichment: Every piece of data is automatically contextualized, and dependencies are mapped to reveal the full picture. However, context also means delivering the right data exactly when and where you need it. To do just that, Dynatrace is bringing these insights directly into Atlassian. This is not just limited to IT service management (ITSM). You can get access to contextualized insights directly within an IDE as described in our latest blog post about the new Dynatrace  MCP Server.

Diagnose faster with context from production at your fingertips

Most incident tickets land on an engineer’s desk with little more than a timestamp, a vague description, or a user complaint. They rarely reveal the severity of the issue, which systems are affected, or what might be causing it. This lack of context in an ITSM workflow forces teams to spend unnecessary time digging through monitoring dashboards, chasing logs, or switching between tools just to piece together the basics of the problem.

Instead of getting frustrated, you can now instantly ask the Rovo Ops agent to identify anomalies that occurred around the incident timeframe. The agent queries Dynatrace via our MCP Server and returns the findings directly in the same browser window.

Having contextual details and alerts available directly in the ticket context means you gain immediate clarity into health, what’s wrong, the impact, and the evidence. This leads to faster diagnosis and quicker recovery, while also reducing unnecessary escalations of already-known or related issues, ensuring internal resources aren’t tied up with redundant work.

Remediate smarter with AI-driven root-cause analysis and automation

Once an incident is identified, the Rovo Ops agent utilizes Dynatrace production insights, which accelerate triage and root-cause analysis for incident managers, pinpointing the actual root cause in real time and delivering a higher level of insight and accuracy.

Rovo can now pull in Dynatrace Causal AI insights, including the precise root cause and blast radius of the issue, and combines these with Jira Service Management incident and change history. With Dynatrace contextual intelligence, Rovo delivers fact-based, AI-generated problem summaries and clear remediation recommendations, outperforming the guesswork of pure GenAI approaches.

From this point, just follow the remediation recommendation and trigger a suggested automation action in Jira Service Management, or ask follow-up questions for clarification.

Learn for the future with automated post-incident reviews

The job isn’t finished after an incident is mitigated and marked resolved in Jira Service Management, as you still need to capture what happened and determine how to prevent its recurrence. Instead of spending hours on manual write-ups, Rovo automatically triggers the post-incident review (PIR) process.

In the auto-generated PIR, Rovo surfaces all of the relevant details and history, from the root cause to detected anomalies, all of which are enriched by Dynatrace AI-driven insights. This provides a complete, time-ordered view of the incident, which is combined with Jira Service Management context attributes like assignees, tags, outage duration, and related change logs. With this context, the agent generates a draft PIR. Inside the PIR, you’ll find monitoring charts showing the status before, during, and after the incident, a clear summary of the cause, and a pre-filled prevention plan. All that’s left for you to do is review, refine, and finalize the PIR.

The automatically documented PIRs act as built-in retrospectives, helping teams continuously mature their operations. They also feed insights back into Rovo to sharpen its future recommendations.

Transform how you work, beyond incident management

These are just a few examples of what’s now possible through the extended Dynatrace + Atlassian integration. We’ll continue to explore deeper integrations to make your troubleshooting journey even more efficient in the future.

Imagine directly following up on investigations from within Rovo, with seamless drill-downs into Dynatrace® Apps, or surfacing related post-mortem information and runbooks stored in Jira or Confluence to SREs when investigating an issue in Dynatrace.

And the potential impact goes well beyond incident management. By bringing reliable, real-time production truth into daily workflow and connecting that truth directly to business outcomes, more teams and roles can fundamentally transform the way they work, harnessing the full power of agentic AI.

• Get instant release validation: Developers can query Rovo for pre- and post-deployment failure rates, SLOs, and outcome metrics, allowing them to release with confidence, roll back faster when needed, and validate hypotheses with real data.
• Make decisions based on outcomes: Product managers can ask Rovo or Davis CoPilot® to analyze the impact of a new feature or release by investigating KPI shifts such as user engagement or a drop in check-outs.
• Speed up triage based on business impact: Support engineers working on Jira tickets see Dynatrace insights related to the root cause, blast radius, affected applications, and services. These insights are enriched with further details on user and business impact, allowing engineers to perform instant impact analysis before assigning tickets.
• Run smarter daily stand-ups: Development teams receive ready-made summaries, including exceptions, user analysis, and deployment reports from the last 24 hours, providing relevant insights into what’s actually happening in production.

Start benefiting from deeper integrations with Dynatrace as your trusted foundation for agentic AI

Dynatrace delivers a deep, causation-based understanding of your live digital systems, providing the precise, reliable insights that enterprises can trust as a foundation for agentic AI.

Ready to see how Dynatrace and Atlassian work together and benefit from adopting agentic AI concepts? Then dig deeper into the new possibilities using our remote MCP Server and experience how real-time production context makes your operations more efficient.

See our documentation to learn more about how to connect the Dynatrace MCP Server.

The post Dynatrace and Atlassian deliver agentic AI that transforms end-to-end incident management appeared first on Dynatrace news.

When you’re navigating petabytes of observability data, looking for relevant information can become frustrating. That’s why we launched Dynatrace segments: a powerful yet simple way to focus on the data that’s important for your specific use cases.

In this blog post, you’ll find out how segments can be easily applied to help you work more efficiently, whether you’re troubleshooting problems, monitoring SLOs, or investigating security threats.

Work smarter in Dynatrace with segments

Think of segments as smart global filters. Segments are:

• Multidimensional: Combine and multi-select different data segments, such as region, team, service, or environment, and apply them instantly.
• Dynamic: Segments automatically adapt as your systems evolve, like when new services are added, new Kubernetes clusters are created, or team responsibilities change.
• Globally available: Selected segments persist as you move through Dynatrace Apps, so you can drill into data without reapplying filters.
• Secure and compliant by design: Segments are fully governed by existing access management policies, ensuring you only see the data they’re authorized to view. Any data outside those permissions is automatically filtered out, independently of which segment is selected.
• Built for scale: Segments are purpose-built for the demands of dynamic, cloud native environments and scale effortlessly to petabyte-level data volumes.

Segments promote self-service data access

Segments can be centrally managed and rolled out to provide a consistent, organization-wide view of data. At the same time, any user can create and share their own segments, whether within their own teams or across the organization.

Building segments doesn’t require complex logic, and upcoming ready-made segments will make getting started even easier. You can define segments around specific entities, such as services or hosts, to automatically include all relevant signals across data types. Alternatively, you can select specific data types individually and apply basic filtering.

However, segments also offer great flexibility for power users who want to create highly granular, dynamic filters based on attributes, tags, or specific field values, leveraging the full power of Dynatrace Query Language (DQL).

Applying segments is seamless and consistent across the platform. You can select segments directly from the top of any app or dashboard. For quicker access, the selector remembers your recently used segments, and you can pin frequently used segments to your menu. For more granularity, simply combine segments with other filters like the filter bar or dashboard variables.

Segments speed up troubleshooting in cloud native environments

Imagine you’re a developer responsible for multiple microservices or applications running across various regions, clusters, and environments. When something breaks or performance dips, you need to access the right data in the right context, quickly.

Segments help by narrowing the view to exactly what matters for you and your team, whether it’s a specific service, an environment, or a region. Instead of sorting through hundreds of unrelated logs or services, you get answers on the spot. This allows you to:

• Instantly understand the health of your services.
  In Services, filter by ownership to view only the services your team is responsible for. Immediately, you can assess key metrics like failure rate, response time, and throughput, then instantly drill down into related logs, traces, or infrastructure components such as Kubernetes clusters and namespaces. Segment context is preserved across all views and drilldowns, so there’s no need to reapply filters or recall complex query syntax.

  

• Triage and resolve problems more effectively.
  In Problems, segments allow you to isolate issues that affect your team’s services, ensuring that only relevant alerts are shown. Define segments based on environment or stage, such as production or staging, to pinpoint problems within a specific context. This makes it easier to compare behavior across environments and direct attention where it’s most needed.
• Break down SLOs to focus on what you own.
  Narrow the scope of your Service Level Objectives (SLOs) to reflect what your team is actually responsible for. With segments, you can filter SLO tiles on dashboards to only include the services, environments, or traffic patterns relevant to your team, such as staging tests or requests from a specific region. This ensures your SLOs accurately represent performance and reliability for your area of ownership. You can also configure alerts to trigger on segment-specific conditions, like an SLO breach in a particular region or service, helping teams take targeted action faster.
• Validate releases with Site Reliability Guardian (SRG) and Workflows.
  Once you’ve focused on the KPIs that matter to your team, use Site Reliability Guardian (SRG) to prevent regressions from reaching production. Segment-specific conditions can be defined directly within individual SRG objectives, enabling automated release validation aligned with your team’s performance standards, executed via Workflows. For example, you can restrict validation to logs from a specific service in a hardening environment, significantly reducing the volume of queried data while ensuring release quality without unnecessary noise.

  

Investigate vulnerabilities and security signals faster with segments

Because not all assets carry the same level of risk or compliance requirements, segments empower you to stay focused by isolating the systems that matter most. Grouping assets in segments opens the door to tiering strategies based on business criticality or risk level, such as production vs. test environments, or high-risk vs. low-impact systems.

This precision becomes even more powerful when combined with the Dynatrace Vulnerabilities app, which highlights those vulnerabilities that are actively exploited at runtime and present real threats, such as internet exposure or access to sensitive data.

Instead of being overwhelmed by hundreds of generic alerts, you significantly reduce the signal-to-noise ratio. For example, if you’re part of a financial services team, you may use segments to first zero in and focus on a critical, customer-facing credit card application service. With Davis® AI assessment, your team is alerted only to vulnerabilities that are exposed, exploited, and urgent. This allows you to respond quickly and to maximize your impact.

Segments also prove valuable during security incident investigations. If there’s a spike in failed login attempts, selecting a segment like app:customer-portal, env:prod, and region:us-east instantly narrows the scope. Within Notebooks or many other Dynatrace Apps, you can explore logs, traces, and metrics tied to that specific context, no manual filtering or tool-switching required. And because segments enforce access controls by design, sensitive data stays protected while investigations remain fast, focused, and compliant.

Boost your efficiency with enterprise-scale filtering

Segments make observability data instantly accessible and actionable for every team. Whether you’re analyzing data in Notebooks, tracking SLOs, troubleshooting in Dashboards, or automating with Service Reliability Guardian (SRG), segments keep you focused, reduce noise, and help you move faster.

Available on the latest Dynatrace, segments bring consistent, dynamic filtering across your entire observability workflow. For more on segments, have a look at our documentation or check out these resources to learn more.

• How segments empower central teams
• How to filter data effectively to find what matters
• How to create and use Segments in Kubernetes environments

The post Cut through the noise with segments: simple, powerful, and dynamic data filtering appeared first on Dynatrace news.

To ensure effective utilization of observability data and meet data governance requirements at the same time, organizations must preserve both technical and business context across massive, fast-moving data streams. This is a complex challenge:

• Maintaining data context: Relating logs, metrics, and traces across domains requires advanced correlation mechanisms. Yet, inconsistent tagging practices across teams and services lead to fragmented views and blind spots.
• Maintaining business context: Observability data often relies on enrichment rules to inject business metadata, such as service owners, cost centers, or deployment tags. These enrichment rules are typically static and hardcoded, requiring constant updates to keep pace with shifting organizational structures, service ownership, and evolving business priorities.

At enterprise scale, these challenges are magnified. Organizations often have hundreds of teams and thousands of users who require access to observability data, each with different needs and use cases. Centralized teams are expected to provide real-time access to relevant data while managing an ever-growing number of filters and governance rules. Manually maintaining and rolling out thousands of static filters across dynamic environments is not only time-consuming; it simply doesn’t scale. To remain effective, organizations need an approach to organizing their data that is dynamic, easy to manage, and empowers users with self-service access to the right data in the right context, without compromising compliance or security.

Dynatrace addresses this with the introduction of Segments, a dynamic, multidimensional, enterprise-grade approach to data segmentation that’s applied at query time. This allows centralized teams to provide smart filtering that removes noise by applying user, team, or application-specific context, while at the same time reducing their maintenance effort.

Decoupling backend data organization from frontend data utilization

Dynatrace is built from the ground up to meet the scale and manageability demands of modern cloud- and AI-native enterprises. With organizations generating petabytes of telemetry daily, Dynatrace ensures real-time ingestion, exploration, and analysis across all data types. Its architecture supports thousands of users across ITOps, SRE, developers, platform engineering, and business teams, while remaining efficient and easy to maintain.

While other observability solutions struggle with scalable, use–case–optimized data segmentation and robust access controls, Dynatrace delivers enterprise-grade manageability with full flexibility to meet any requirements. It decouples compliance and security from day-to-day data usage, enabling both control and agility at scale.

To support this, Dynatrace introduces three core concepts that feature segments as a key part of the solution:

1. Data partitioning (buckets): Organize data logically to meet performance, compliance, and retention requirements. Think of a bucket as a folder in a filesystem. Use buckets to group telemetry data that naturally belongs together, for example, data from the same region, environment, or with the same sensitivity classification.
2. Data access (IAM): Stay flexible and meet compliance and security demands by defining fine-grained access to data and Dynatrace platform capabilities based on a user’s context. Use IAM to manage fine-granular permissions, enforcing enterprise-grade governance.
3. Data segmentation (segments): Enable real-time filtering across massive data sets without the need to create thousands of individual rules. Segments are fully governed by existing access controls, ensuring that users only see the data they’re authorized to access.

Use segments across your organization

Segments bring business context to observability data and are consistently available across the Dynatrace platform. The key benefits of using segments are:

• Dynamic, not static: Segments adapt automatically using variables, keeping filters relevant as environments evolve. New services, Kubernetes namespaces, and more are picked up without manual updates. Segments are multidimensional, so users can combine them to zoom in on their data.
• Performance-optimized pre-filters: Applied at query time, segments scope queries to only the selected data segment, reducing overhead and increasing efficiency.
• Establish shared, global data views, aligned to business logic: Structure data segments, for example, by data ownership region, business unit, environment, or application. Provide a consistent source of truth across the organization.
• User-created context: By combining centrally managed segments with their own custom filters, users can personalize their views without involving the centralized team.
• Built for scale: Real-time filtering across petabyte-scale data volumes, by thousands of users, without compromising performance.

Consider the following examples, how different roles can use the same set of segments to tailor their view of shared data to their specific needs.

• An IT Ops team looking to quickly assess infrastructure health in a specific region does this by combining segments for region with host group, cloud provider, or Kubernetes cluster, instantly narrowing the scope.
• Developers troubleshooting a web app select the segment focusing on all data related to this particular app, and combine it with an additional filter for Kubernetes namespaces to zoom in on logs, metrics, and traces tied to that exact deployment. They then layer on details like error types or device models to pinpoint exactly where issues occur. This allows them to rapidly identify issues and improve stability and user experience.

Although both teams work from the same unified observability dataset, segments dynamically apply each user’s individual context at query time, ensuring they only see what’s relevant.

Tip: To further customize the Dynatrace experience for different roles, familiarize yourself with Launchpads, our central entry point for users that consolidates relevant resources and makes their Dynatrace experience more personal and relevant. Learn more about Launchpads.

Discover how to leverage segments in your organization

For more on how to get the most out of segments, explore our documentation and these helpful resources:

• The benefits of segments for users
• How to use segments for advanced log analysis
• How to best use filtering and segments on dashboards
• How to segment data by Kubernetes clusters

The post Segments empower centralized teams to dynamically organize data at petabyte-scale appeared first on Dynatrace news.

We’ll walk you through a real-world example of monitoring OpenAI APIs in production to show you what this looks like in action.

In practice: Create a dashboard monitoring OpenAI LLM APIs

Imagine you’re on a platform team at a SaaS company that recently integrated OpenAI to power features like smart search, summarization, or chatbots. With these capabilities now live, your next challenge is ensuring they perform reliably, scale efficiently, and stay within budget. This is where Dynatrace shines—helping you transform telemetry into insights that drive action.

Let’s walk through all the steps to create just such a dashboard, and dig deeper to:

• Find and add (OpenAI telemetry) data with ease.
• Tailor visualizations to understand token usage, latency, and error metrics easily.
• See what matters: filter and segment data by LLM model, service, or environment.
• Predict and prevent issues: avoid model response slowdowns and cost spikes.

Find and add (OpenAI telemetry) data with ease

Creating a new dashboard begins with identifying and understanding the relevant data for your use case. Monitoring LLM APIs requires the visualization of key metrics like request volume, latency, or error rates per model. With Dashboards, exploring your data is intuitive, providing multiple ways to search for and analyze data.

• Start with a ready-made dashboard that provides instant insights
• Explore data using a simple-to-use point-and-click interface—ideal for getting started by quickly adding tiles
• Utilize the full power of Grail by writing your own DQL query or utilizing Davis CoPilot® to transform your natural language prompts into DQL queries.

As an experienced Dynatrace user, you’re familiar with exploring data in context with our purpose-built apps like Kubernetes, Logs, or Distributed Traces, and how to add visualizations from those apps to your dashboards.

Let’s look at some of these approaches in the following sections.

Start the journey with ready-made dashboards

You don’t have to start from scratch. Dynatrace offers many ready-made dashboards as part of Dynatrace® Apps and purpose-built extensions to serve dedicated use cases. As the leading observability solution for monitoring AI workloads, we offer dashboards for all major AI and LLM stacks, including agentic frameworks such as OpenAI, Anthropic, Amazon Bedrock, or NVIDIA. These dashboards provide instant value, whether you’re monitoring performance or debugging expensive prompts. By delivering real-time insights into request volume, latency, cost, and service health, they not only save you time but also create a solid foundation for tailoring their experience to your needs.

Let’s start our journey by opening the ready-made dashboard for OpenAI and creating a copy of it. To follow along, locate the Dashboards app on the Dynatrace Playground.

Add further tiles to analyze token usage

Next, let’s add another tile to visualize the overall prompt token usage by type: input vs. output for OpenAI services. From discussions with our platform observability team, we know that all relevant metrics sent to Dynatrace using OpenTelemetry are available as custom metrics prefixed with gen_ai. We add a metrics tile and type gen_ai into the search field. This instantly surfaces all related telemetry. A few clicks later, applying data splits and aggregations, we have two more tiles, demonstrating how simple it is to turn raw telemetry into actionable insights:

• A pie chart that shows the balance between input and output tokens
• A line chart that tracks how the usage evolves over time

Figure 2. Visualizing overall prompt token usage.

For further insights into the exploration and transformation possibilities in Dashboards, check out our blog post on transforming data into insights.

Leverage the power of Dynatrace Grail

Not sure where to start, which metric to use, or how to quickly advance with the power of Dynatrace Query Language (DQL) and Grail® data lakehouse? That’s where Davis CoPilot® comes in. Built directly into Dashboards and Notebooks, Davis CoPilot allows you to interact with your data using plain language—no need to write queries or know exact metric names. Just type something like Visualize token usage by input and output types, and the AI will help you instantly generate the appropriate query, taking you from question to insight in seconds.

Figure 3. Use Davis CoPilot to create and visualize queries instantly.

Tailor visualizations to easily understand token usage, latency, and errors

As someone responsible for monitoring systems or ensuring service reliability, you know how important it is to get the right insights at a glance. Dynatrace helps you build intuitive dashboards that focus on what matters most: understanding your data and taking action on it.

Once the data is set and a tile added, Dynatrace automatically suggests the most suitable visualization. For example, when tracking API token usage by type over time, a line chart is recommended to highlight trends and fluctuations.

Dynatrace also applies other smart defaults based on the context of the visualized data. For example, when you add a metric that tracks the usage of example prompts and split it by the prompt name, sparklines are automatically included to show trends over time—no extra configuration needed. And if you’re already a power user, the newly added search speeds up your dashboard creation journey by offering a way to instantly jump to any configuration without the need to scroll around. But there’s a lot more that helps improve the user journey. We harmonized the settings of individual visualization types, ensuring that already defined configurations, such as color palettes or units, persist, even if you change the type.

We’ve also made many updates to the chart plotting features of our pre-existing visualizations. For example, the single value tile, which used to be a basic number display, is now a highly expressive component. You can now enrich the single-value tile with icons, apply color thresholds to flag anomalies, add sparklines to show trends, and add value and trend labels that provide additional context for the charted value and give it meaning.

Plotting the values on a map benefits many signals. Consider displaying token usage or prompts issued per destination. The map component has a rich set of customization options—such as color rules, pin shapes, and unit formatting—explicitly designed to support the visualization of geographic data.

See what matters: filter and segment data by LLM model, service, or environment

To make a dashboard truly actionable, the next step is to add filters and segmentations. This allows you to tailor one view dynamically for different audiences, environments, or services, all within a single dashboard. For example, you might filter an OpenAI dashboard by environment (production, staging, test) or model type (GPT-4.1, o3, o3-mini) to focus on what matters most in each context.

Dynatrace offers powerful ways to filter data:

• Using reusable segments, multidimensional global filters can be applied to all tiles and data. This is ideal for applying a specific (user) context, such as environment, team, or cluster. Segments are persisted across navigation between apps, allowing for simple drill-down journeys.
• With variables, we introduce Dashboard-specific filters, offering fine-grained control for each tile, perfect for filtering information such as LLM model type or feature toggles.

If you want a more in-depth tutorial, check out our latest blog post on filtering.

Predict and prevent issues: avoid model response slowdowns and cost spikes

Dashboards aren’t meant to be stared at all day. In most organizations, they’re often left untouched until something goes wrong. That’s when dashboards become invaluable: surfacing the correct data at the right time to help teams quickly understand, diagnose, and resolve issues.

From passive observation to proactive action, Dynatrace bridges the gap with interactive, AI-powered dashboards that don’t just visualize data; they empower you to act on it. You can add alerts and forecasts directly from charts with just a few clicks.

For example, suppose your dashboard tracks OpenAI model response times and associated costs. In this case, you can set an alert to notify your team if the average response time exceeds a certain threshold for a defined period directly from within the chart. This ensures you’re reacting to issues and anticipating them before users are impacted.

Another popular example of proactive monitoring is cost forecasting. Our dashboard already tracks cost trends over time—such as “prompt costs” and “complete costs,” for example—with a line chart highlighting weekly fluctuations.

By enabling forecasting, Dynatrace projects future spending based on historical usage patterns. This helps you anticipate budget overruns, adjust resource allocation, and make informed decisions before costs spiral. The predicted budget spend is shown alongside a table highlighting the “Top 10 expensive prompts.” This allows teams to identify which workloads or user actions contribute most to spending, ideal for optimization efforts or chargeback models.

Share with teams: secure, flexible collaboration

The next step is to share our dashboard with the right people, ensuring teams are aligned across job roles and departmental boundaries. The new Dynatrace Dashboards supports flexible sharing options for collaboration within your organization.

Fine-grained collaboration settings allow you to:

• Share a document with specific users or groups applying either view or edit permissions.
• Roll out a dashboard to users in the environment.
• Generate a link that works for any authenticated user in your environment—ideal for broad internal visibility without managing individual access.

Ready to try it out yourself?

Dynatrace Dashboards redefine how teams interact with observability data. Whether you’re monitoring LLM APIs, optimizing cloud costs, or ensuring service reliability, Dashboards empowers you to:

• Explore data intuitively.
• Visualize insights using smart defaults and rich customization options.
• Segment and filter your data dynamically, offering tailored views for use cases.
• Act proactively on data anomalies using forecasting and creating alerts in context.

Experience the power of Dashboards: Head over to the Dynatrace Playground and browse the ready-made dashboards or create your own, following the steps described in this blog post.

The post From data to insights with Dynatrace Dashboards appeared first on Dynatrace news.

Dynatrace dashboards offer several ways to filter data, each suited for different use cases. By the end of this tutorial, you’ll know how to:

• Apply instant ad-hoc filters directly on tiles
• Filter across multiple tiles using variables
• Leverage Segments for platform-wide filtering aligned with business context

We’ll walk through these different techniques using one of our ready-made dashboards to monitor Kubernetes resource usage. This dashboard has been developed for troubleshooting and performance analysis; you can find it on the Dynatrace Playground.

To follow along, start by duplicating the dashboard. Open the dashboard list, search for “Kubernetes Namespace – Pods”, and select “Duplicate” from the context menu next to the dashboard name.

Fast and focused: filter your data instantly in the tile configuration

First, let’s explore how to define individual filters for each tile.

Imagine we want to enhance our Kubernetes dashboard by adding log data to provide deeper context, such as errors, warnings, or other significant events, alongside our performance metrics. This enhancement helps to correlate issues faster and improve troubleshooting efficiency.

We use the filter field in the tile configuration narrowing down the visible data, focusing only on error messages, by adding

loglevel = ERROR

Once you hit Run the new filter is applied. If you want to exclude unnecessary log levels instead, you could do so by changing the filter condition to:

loglevel != INFO

We could also filter our logs by specific services, message content, or log sources. Applying filters works the same on all other data tiles, like metrics or business events.

Query and filter your data with natural language or DQL

Alternatively, you can filter your data by adding the filter condition to the query itself. You can also use Davis CoPilot™ for that. Just add a CoPilot tile to Query with AI and include the desired filtering as part of your prompt:

Fetch all logs and filter only those where loglevel equals ERROR. Only show me the last 100 logs.

Davis CoPilot automatically translates your input into Dynatrace Query Language (DQL). To view the generated query and see how the filter command is applied, select DQL directly below the prompt field.

Do you want to go deeper? DQL offers very powerful filtering capabilities and flexible alternatives like the recently launched Search command, which is ideal if you’re unsure where or how specific information is stored in your data. For more, check out the topic How to use DQL queries in our documentation.

Dynamic filtering across multiple tiles using variables

So far, we’ve focused on adding static filters to specific tiles. Using variables, you can easily make your dashboards interactive, applying filters across multiple tiles in real time.

For example, if you’re comparing resource usage across several Kubernetes namespaces, doing it manually means editing each tile to change the namespace, every single time. That’s time-consuming and prone to mistakes. Variables solve this by letting you filter tiles from a single input.

Defining variables is simple and straightforward: the easiest way is to start with static variables, where you manually add a list of entries as free text. You can also use a CSV file as input for the list.

But you can also use dynamic variables, where the entries are based on data stored in Grail or fetched externally. The benefit of this approach is, that in case a value changes, the variable is always automatically updated.

Our example dashboard already provides some variables, like Cluster and Namespace. By clicking on the overflow menu on the top right, you can add view and edit existing variables or add new ones.

You can also use hidden variables, which are not visible as a drop-down but used behind the scenes to power specific tiles and keep the dashboard clean and focused.

Add variables to tiles

First, let’s enhance the filter statement of our log tile by adding a variable. This is similar to using a static value, but now we reference an existing variable using the $ symbol followed by its name. Let’s update the filter and add the cluster name and namespace.

Once saved, you can use the dropdowns at the top of your dashboard to filter the data in the log tile we have updated before. Variables are supported by all tiles. To learn more, visit the topic Add a variable to a dashboard in our documentation.

Use Segments to create filters aligned with the business context

Segments are used to logically structure data in Dynatrace. They are dynamic and multi-dimensional, offering a simple to way to slice data and persist the filtering across apps. They introduce a way to add (business) context of a specific users, based on real-world dimensions, such as org units, hyperscaler regions or infrastructure components.

In our example, we’ll use a Segment that is already defined on our tenant. You can select Segments by selecting the square icon at the top right corner of the dashboard.

Let’s apply the “K8s cluster” and “K8s namespace” Segments. When you select the K8s cluster Segment (e.g., aks-playground), it uses a variable to dynamically list all available monitored Kubernetes clusters. It also includes predefined conditions to automatically pull in all related data for the selected cluster.

Keep in mind: every time you apply a Segment, it acts as a pre-filter across your data. While you won’t see it as a visible query condition, it’s applied as the first filter on your dashboard.

Segments are multidimensional, meaning you can layer them for more precise filtering. Stacking the K8s namespace Segment (for example, astroshop) further narrows the scope. Your dashboard tiles instantly reflect only the data relevant to that namespace, without requiring any manual updates on the tiles.

Since data is prefiltered based on the selected Segments, this approach improves performance and reduces the volume of data processed, which is especially useful at scale.

If you want to learn how to build your own Segments, please have a look at our Kubernetes segments tutorial.

See Dynatrace dashboards and variables in action

We have now learned different ways to slice and dice data within Dynatrace Dashboards. If you want to see a different example, check out this observability lab video by Andreas Grabner, where he walks you through practical use cases:

The post Power dashboarding part 3: Filter data effectively to find what matters appeared first on Dynatrace news.

Empowering real-time insights through petabyte-scale data processing of all your data

Modern cloud native systems generate massive volumes of telemetry data, spanning logs, metrics, events, and traces. Extracting real-time, actionable insights and enabling meaningful alerting and root cause analysis requires more than just centralized data storage; it requires a scalable data pipeline. Without such a pipeline, even the most advanced analytics tools are constrained by data flow and preparation bottlenecks. To address these challenges, we launched OpenPipeline, our unified data ingest solution for the Dynatrace® platform. OpenPipeline is a customizable, scalable data pipeline for ingesting, transforming, and harmonizing data for reliable analysis and correlation.

With its latest enhancements, OpenPipeline supports real-time data processing even at petabyte scale, by reliably handling high volumes of logs, traces, and other telemetry. This level of scalable pipeline processing is essential for delivering timely insights, enabling Dynatrace to:

• Detect anomalies across distributed systems in real time
• Perform proactive security analytics and real-time vulnerability detection
• Offer real-time insights into your business processes

Scale is not only about the sheer amount of data signals. It’s also represented in the size of individual signals that can be handled. An increasing number of use cases, such as parsing JSON/XML request bodies, capturing detailed audit logs, exploring transactional data dumps, or analyzing input vectors from ML model logs, require the ability to efficiently process large log files. With the release of Dynatrace version 1.311, OpenPipeline now supports log records up to 10 MB in size, empowering you to use Dynatrace for high-volume use cases. For more information, have a look at this Dynatrace support for large log records blog post.

Break silos with unified ingestion across all data types

Alongside scale, OpenPipeline provides unified ingestion across all data types, removing silos, simplifying integration, and ensuring that all data, regardless of format or source, is enriched, contextualized, and processed in the same tool, ready for advanced analytics.

Recent enhancements to data type processing include:

• Spans: You can now configure how spans are processed, including dropping specific fields or entire records, and assign a security context for fine-grained, record-level access control. Spans can also extract metrics and route them into defined target buckets. Full ingest functionality for spans is coming soon.
• RUM data: Ingesting Real User Monitoring (RUM) data, including user events, sessions, and associated metrics, is currently in preview and will soon be made generally available for all Dynatrace SaaS customers.
• Events: OpenPipeline now supports custom processing rules for a broad range of event types, including security events, software development lifecycle (SDLC) events, business events, and Dynatrace internal system-level events.

Simplified pipeline management from setup to optimization

Historically, setting up pipelines for data ingestion involved time-consuming configuration of parsing, field mapping, and transformation logic for each data source. OpenPipeline now streamlines this process with ready-made processor bundles for widely used technologies and formats, accelerating data onboarding and standardizing data handling at scale for ingest sources such as:

• Hyperscaler support, including AWS and Azure
• Web servers like Apache, IIS, JBoss, HAProxy, or Nginx
• Programming languages like .NET, PHP, Java, Python, or NodeJS
• Databases and app frameworks like Elastic or Cassandra

With just a few clicks, you can apply a processor to a source, ensuring all fields are parsed correctly, attributes are renamed, and data structures are accurately standardized. Each bundle includes example records that can be tested interactively, with further customization available to meet specific requirements. This allows your teams to onboard new telemetry streams in minutes instead of hours. We’ll continue to expand our support to cover more technologies in the future. You can also create your own processors to handle any custom format.

Reveal hidden value with data transformation

Upon ingestion, modern observability, security, and business data can be structured in varying, often complex forms. OpenPipeline offers advanced transformation capabilities that allow for easy extraction of relevant data beyond the creation of simple events and metrics:

• Extract values from deeply nested JSON fields. For example, extract the threat identifier from a JSON-formatted security event and convert it into a security metric.
• Create unified metrics from different data types. For example, consolidate error codes from both logs and spans into a single metric for cross-service comparison.

Stay informed: Real-time visibility and alerting for your pipelines

To optimize pipelines, teams need visibility into their performance. OpenPipeline now exposes detailed metrics at key processing stages: ingest, routing, and output, as well as not-stored-records. With these metrics, you can instantly verify any pipeline configuration and detect anomalies early.

These metrics power:

• Real-time microcharts within the OpenPipeline user interface, showing data trends and ratios over the last 30 minutes.
• A ready-made dashboard used to explore daily or weekly summaries, historic volume trends, and detailed routing stats by pipeline or source.
• Smart alerting. Traffic fluctuations on ingest are common, so you can leverage AI-powered dynamic baselining to raise custom alerts and detect anomalies before an issue occurs.
• Automated operations that trigger notifications or perform autonomous remediation steps once an ingest anomaly or traffic volume deviation is detected.

Easy transition to OpenPipeline for existing customers

For Dynatrace SaaS customers using classic pipelines, we’ve simplified the transition to OpenPipeline. Start utilizing OpenPipeline for new data sources while keeping your existing log processing configurations fully operational and uninterrupted. This side-by-side, risk-free approach supports gradual adoption and allows you to modernize your data processing without disrupting ongoing workflows.

Get started today

OpenPipeline is now available to all customers running the latest version of Dynatrace SaaS. Already today, you can:

• Benefit from processing a broad range of data types, including logs, traces, events, and RUM data (currently in preview).
• Take advantage of processing the full payload of large log records, parse embedded XML or JSON structures, parse events or metrics from complex log records, or use them for deep search analytics and forensic use cases—all without splitting individual log lines into separate events. Leverage the built-in processor bundles to get started with popular formats.
• Explore the ready-made OpenPipeline dashboard on the Dynatrace Playground.
• Use real-time pipeline metrics to tune and optimize your configurations.

The post Latest OpenPipeline upgrades simplify high-volume, real-time data processing appeared first on Dynatrace news.

Welcome back to our power dashboarding blog series, data enthusiasts! Today, our Dynatrace Dashboards tutorial will dive into some exciting features to level up our dashboards with little effort:

• Create charts effortlessly with Davis CoPilot™ using a natural language interface.
• Analyze your charts with AI to gain instant insights into trends and anomalies.
• Guide users with highlight formatting based on conditions, optimized visuals, and icons/emojis.

You can either continue with the custom infrastructure metrics dashboard you created in Part I or use the dashboard we prepared here (Dynatrace login required). By the end of this session, your enhanced dashboard will look like this:

Looking for something? Query your data with natural language

Davis CoPilot is an excellent virtual assistant that helps you create queries using natural language. While the Explore interface is useful for quickly visualizing known metrics, Davis CoPilot is great for exploring your data when you know your desired outcome but are unfamiliar with the available data. exploring your data when you know your desired outcome but are unfamiliar with the available data.

In our Dynatrace Dashboards tutorial, we want to add a chart that shows the bytes in and out per host over time to enhance visibility into network traffic. By tracking these metrics, we can identify any unusual spikes or drops in network activity, which might indicate performance issues or bottlenecks. To simplify the data and make it more readable, we’ll show only the entity names instead of the host IDs. This approach helps you quickly pinpoint potential problems and ensures efficient monitoring of your infrastructure.

Since we’re unsure which metric to use, we turn to CoPilot, using natural language to express what we’re looking for. For this tile, we’ll use the following prompt:

“Show me the bytes in and out by host over time, add the entity names for the hosts, and remove the host id.”

Create a chart with Davis CoPilot, visualizing bytes in/bytes out

1. Select + to create a Davis CoPilot tile.
2. In the options pane, select the Data tab and enter the natural language prompt above in the text field. Select Run.
3. Go to the Visual tab and update the visualization to Categorical. The resulting tile displays the transmitted and received bytes, split by host. By default, dashboards show data from the last two hours. You can adjust the timeframe at any time using the selector located in the upper right corner of your dashboard.

   

That’s how easy querying your data and creating charts with Davis CoPilot can be. For more information on optimizing your prompts and best practices, check out the topic Tips for writing better prompts.

Now, let’s take our Dynatrace Dashboards tutorial a step further by using AI to analyze our charts and gain additional insights with the predictive capabilities of the Davis® AI Analyzer.

Upgrade your chart with an AI-powered trend forecast

In our dashboard, we already have a tile displaying CPU usage. Let’s enhance this chart with a trend outlook to gain insights into future CPU usage patterns. By monitoring and predicting CPU usage, we can ensure optimal performance, prevent potential bottlenecks, and proactively manage resources to maintain smooth system operations.

Add Davis® AI Analyzer to the CPU usage % chart

1. Go to the Data tab and expand the Davis AI section at the bottom.
2. Select the Activate Davis AI Analyzer toggle and select Forecast from the drop-down menu.
3. Leave the default parameters and select Run.
4. Go to the Visual tab and select the Davis AI Analysis category.
5. Select the Chart option from the Davis AI Analysis category.

   

You may have noticed the option to activate anomaly detection when adding forecasting. This feature provides immediate insights into unusual spikes or drops in your telemetry data. For more information, have a look at our recent blog post on utilizing Davis AI on dashboards.

Formatting Dynatrace Dashboards for enhanced usability and faster insights

By adding formatting to dashboards, you can improve usability, highlight important information, and make data easy to digest. Dashboards offer various ways to enhance data appearance, from simple color updates to conditional formatting based on rules.

To make it easy for users to quickly identify what’s important, format your charts to clearly display that information. We’ll now review and improve each dashboard tile to ensure it is user-friendly and easy to understand.

Access the customization options by going to the Visual tab of your selected tile.

Here, you can reassign data mapping, modify data representation, adjust the X/Y axis, change data colors, set thresholds, and assign units and formats to provide more context to your data. Depending on the selected visualization, you have various options for modifying the tile’s visuals.

Improve the DNS errors single-value tile

Let’s start by adjusting the visuals of the DNS errors tile. We want to make the information instantly clear to the user and modify the sparkline with ticks to better illustrate how the metric changes over time.

1. Select the tile and go to the Visual tab.
2. Expand the Single value section.
3. Using the Show label option, update the label to DNS errors.
4. Enable the Show icon option and select Network icon.
5. Expand the Trend section. Update the arrow colors to red, blue, and green. Red indicates that the number of errors is increasing.
6. Expand the Sparkline section. Set the Variant option to Area and enable Show ticks.

   

Improving the Inodes pie chart

For the pie chart displaying the total number of Inodes, we’ll adjust the colors to ensure consistency across the dashboard and minimize distractions. Blue will be used as the primary color to maintain a uniform palette. In other instances, it often also makes sense to use colors to indicate functional differences or common categories across different charts.

1. Select the tile and go to the Visual tab.
2. Select the Color section and expand it.
3. Expand the Series colors option and select the Blue-steel category.

   

Improving the Memory used % chart

To further reduce noise in our Dynatrace Dashboards tutorial, we’ll hide all displayed legends related to entity hostnames, retain only the essential fields, and update the color palette.

1. Select the tile and go to the Visual tab.
2. Select the Y-axis section, expand it and delete from the label to only leave entity.name.
3. Go to the Legend and tooltip section and expand it.
4. On the Displayed fields option, expand the list and uncheck dt.entity.host field.
5. On the Show legend option, disable the toggle.
6. Go to the Color section and expand it.
7. In the Series colors option, select the list to expand it.
8. Select the Blue-steel category.

   

Use conditional formatting to highlight information in tables

Using conditional formatting in a table helps highlight important data points and trends, making it easier to spot anomalies and patterns at a glance. It also enhances readability by visually distinguishing between values based on predefined criteria.

Let’s enhance the visuals for the table displaying disk usage. We’ll hide some of the fields currently displayed and add a threshold for average disk usage by host using conditional formatting.

1. Select the Columns section and expand it.
2. On the Displayed fields option, select the list and uncheck the timeframe and interval fields.
3. Go to the Cells section, expand it and change the Apply threshold color to option from Value to Background.
4. Go to the Threshold section and select it.
5. Select + Threshold. This will add a new threshold with three predetermined rules with empty values.
6. On the Field option, select value.A.
7. Change the three operators for the rules from ≥ to ≤.
8. Modify each of the Value fields as displayed in the image below:
   • Green: No action required.
   • Yellow: Attention, potentially action required.
   • Red: Warning, action required.
9. Go back to the Cells section and enable the Show threshold in row option.

   

   

Add icons and emojis in markup tiles

Including icons on your dashboard can enhance visual appeal and make it easier to quickly identify and interpret key information. Icons can also improve user experience by providing intuitive visual cues that guide users through the data. Dashboards support emojis and icons for that purpose, making it easier for users to identify the information they’re looking for quickly.

Add emojis/icons

1. Select Windows key + . (period) on Windows or Fn + e on Mac in any markdown or text field.
2. We’ll add a 🖥️ computer icon to the main title of our dashboard and incorporate more emojis in the subtitles. This will help users to faster navigate to the information they’re looking for.

   

Dynatrace Dashboards tutorial: Where to go from here

With this Dynatrace Dashboard tutorial, you now have a solid understanding of dashboarding basics and are familiar with several customization options.

If you want to continue your learning journey, here are some recommended sources for further reading.

Learn more about customizing visualizations: Discover various ways to tailor the visual elements to better suit your needs.
Collaborate and share your dashboards: Enhance teamwork by sharing and working together on dashboards.
Experiment with filtering by utilizing variables: Dive into using filters based on variables to refine and personalize your data views.

The post Power dashboarding part 2: Dynatrace Dashboards tutorial to gain better, faster answers using AI and formatting appeared first on Dynatrace news.

Welcome, data enthusiasts! Whether you’re a seasoned IT expert or a marketing professional looking to improve business performance, understanding the data available to you is essential.

That’s where Dynatrace dashboards come in. They aren’t just fancy visuals; they’re your go-to tool for making sense of your data, understanding correlations, and gaining real-time insights.

With Dashboards, you can monitor business performance, user interactions, security vulnerabilities, IT infrastructure health, and so much more, all in real time. You can even drill down to discover the root causes of issues—all from a single view. Dynatrace offers ready-made dashboards for many use cases that you can immediately start using. For all other use cases, you’ll find that creating custom dashboards and gaining valuable insights is quick and easy, and dashboards are incredibly versatile in meeting your specific requirements.

In the power dashboarding blog series, we’ll guide you through creating powerful dashboards that transform complex data into actionable insights.

Starting from scratch, we’re going to show you how to

• Create charts with just a few clicks
• Enhance your dashboard with AI
• Make your data look beautiful
• Approach and execute complex queries
• Use readymade dashboards as a fast route for deep insights
• Interact with your dashboards to speed up problem resolution
• Boost user experience by applying design best practices
• Make the most out of variables and advanced filtering

Learn how to create charts with just a few clicks

In this first installment, we’ll guide you through creating the simple dashboard shown below using the Explore functionality. In our next blog post, we’ll further enhance this dashboard with AI and increase its visual appeal and usability.

We will create a basic Host Monitoring dashboard in just a few minutes. Even if infrastructure metrics aren’t your thing, you’re welcome to join us on your power dashboarding journey – simply swap out the suggested metrics for ones that interest you. By following along, you will learn how to create custom dashboards and get to know different chart types.

Host Monitoring dashboards offer real-time visibility into the health and performance of servers and network infrastructure, enabling proactive issue detection and resolution. Good dashboards cover a broad range of metrics, and Dynatrace already provides an expertly developed, ready-made infrastructure dashboard that covers most use cases. However, creating a custom dashboard can be incredibly useful if you want to gain insights into specific hosts or issues.

For our example dashboard, we’ll only focus on some selected key infrastructure metrics. Let’s begin by creating your dashboard.

Power dashboarding: Create a dashboard from scratch and familiarize yourself with tiles

If you’re an existing Dynatrace customer, simply navigate to Dashboards. First-time users can follow along on the Dynatrace Playground.

Create a new dashboard

In the Dashboards app, select + Dashboard. You can update the name of your still empty dashboard by clicking on untitled dashboard to Host Monitoring.

Add tiles

In Dynatrace, visualizations and other elements on your dashboard are called tiles. Here you can find more information on the different types of tiles.

Let’s start our power dashboarding exploration journey by adding our first Metrics tile: DNS errors.

DNS errors detail the number of failed DNS queries and serve as a valuable KPI for host monitoring. This information is crucial for identifying network issues, troubleshooting connectivity problems, and ensuring reliable domain name resolution.

For near real-time analysis, we’ll focus on DNS errors within the last two hours and visualize the number of errors within this timeframe as a single-value visualization.

Additionally, we’ll include a trend indicator to show changes in the quantity of DNS errors compared to the previous data point and add a sparkline to visualize DNS errors over time.

Figure 3: Add dns_errors to your dashboard and show it as a single value chart

Creating a single-value chart showing DNS errors

1. Select + in the upper right corner to show the list of available tiles.
2. A new tile will appear on your dashboard.
3. A panel with the tile options appears on the right side. To find the metric, go to the “Explore” section on the data tab.
4. Click on Select metric. Select the category Infrastructure and then DNS.
5. Select Number of DNS errors by type.
6. Now you can choose a calculation for your metric. Next to your selected metric, you see avg as default selection. Change it now to sum.
7. Below, you see the Split by We don’t need this one for now, so we can remove it by selecting x. Instead, click on the + button right below and select Reduce to single value. Update the calculation to Sum.
8. Finally, select RUN.
9. Now, all that is left is to update the visualization. Go to the Visual tab and change the visualization type to Single Value.

Congratulations. You’ve created your first visualization on your dashboard. As you went through these steps, you likely noticed some of the chart options available. Not only can you select a metric, but you can also add multiple filters, use sorting, or directly apply calculations like average or sum. For more information, you can always check our documentation.

Next, we want to gain visibility into disk usage, particularly the disk space used for each host. We’ll split the data by host, calculate the average percentage, and add a time series to understand the behavior over time.

The best way to visualize all this information in a single chart is a table.

Creating a table on disk usage

1. Create another Metrics
2. This time use the Search function to find the Disk used % Alternatively, select it from the category Infrastructure/Disk.
3. Leave avg as default for the calculation.
4. Leave Split by and select to split by name.
5. Click on + (the one which is directly placed over the RUN button) and add Sort.
6. To sort the filtered data, select `avg(dt.host.disk.used.percent)` from the list. By default, sorting will be
7. Select Run.
8. Go to the Visual tab and change the visualization type to Table.

Great job! I believe you’re getting the hang of it.

We’re now adding Inodes Total as a pie chart to our dashboard. Monitoring the total number of inodes helps ensure the filesystem remains healthy and prevents errors caused by running out of inodes. It also provides insights into system performance and allows for proactive management.

Creating a pie chart showing Inodes

1. Create a new Metrics
2. Add the Inodes Total metric from the category Infrastructure/Disk.
3. Leave avg as default for the calculation.
4. Leave Split by and select to split by name.
5. Add Sort.
6. Select`avg(dt.host.disk.inodes_total)` and sort
7. Select Run.
8. Go to the Visual tab and change the visualization type to Pie.

You’re making fantastic progress with your dashboard!

We want to determine the average memory usage for each host and condense the results into a single value. Monitoring average memory usage per host helps optimize performance and manage resources efficiently. It also aids in troubleshooting and controlling costs by identifying memory inefficiencies.

Creating a single-value chart showing memory usage

1. Create a new Metrics
2. Select Memory used % from the category Infrastructure/Memory.
3. Leave avg as default for the calculation.
4. Leave Split by and select to split by name.
5. Add Sort.
6. Select `avg(dt.host.memory.usage)` and sort
7. Select Run.
8. Go to the Visual tab and update the visualization to Categorical.

Finally, we also want to add CPU usage to our dashboard. Monitoring CPU usage helps ensure optimal performance, enabling you to manage your resources and ensure smooth system operations proactively.

Creating a timeseries chart on CPU usage

1. Create a new Metrics tile.
2. Select CPU usage % from Infrastructure/Disk.
3. Leave avg as default for the calculation.
4. Leave Split by and select to split by name.
5. Select Run.
6. The recommended, default visualization should be a Line chart. (if not, go to the Visual tab and updated the visualization to Line chart).

Isn’t it marvelous? You have created your first dashboard in just a few minutes. In the final step for now, we will just add some simple structure to your dashboard.

Arrange your charts and add some structure

We want our dashboard to be well-structured to make it easier for users to find relevant information. First, we can easily adapt the size of our charts and move them around on our dashboard:

Titles and additional information are also good ways to add more structure. For that, we use markdown tiles. Markdown tiles enable adding text, images, links, or key points.

Add titles to your dashboard

1. Create a Markdown
2. In the options menu we can now provide the text we want to show. For a title, we select H1 and write Host Monitoring as a title text after the #:
3. Then, we add a break and write “—” to add a line below the headline.

You can now add additional subtitles or provide written guidance to new users on how to use and understand the dashboard.

Power dashboarding: Where to go from here

You’ve now learned the basics of dashboard creation on your power dashboarding journey. Stay tuned for Part 2 of this series, where we’ll explore how to harness AI to elevate your dashboard to the next level. We will also introduce you to various options to make your dashboard even more visually stunning.

In the meantime, if you’re eager to deepen your knowledge of Dynatrace dashboards, we recommend exploring the following resources:

• Play around with different types of tiles: Familiarize yourself with the various tile options.
• Interact with your dashboards: Utilize the Open with function to delve into use case-specific Dynatrace Apps. Additionally, use panning and zooming features to gather more detailed information directly on your charts.
• Learn from experts: Duplicate ready-made dashboards to tailor them to your needs. Examine the underlying configurations to gain insights into creating complex dashboards. Also, explore additional dashboards available on the Dynatrace Playground.

The post Power dashboarding part 1: Start your exploration journey with Dashboards appeared first on Dynatrace news.

Ensuring smooth operations is no small feat, whether you’re in charge of application performance, IT infrastructure, or business processes. Chances are, you’re a seasoned expert who visualizes meticulously identified key metrics across several sophisticated charts. Your trained eye can interpret them at a glance, a skill that sets you apart.

However, your responsibilities might change or expand, and you need to work with unfamiliar data sets. The market is saturated with tools for building eye-catching dashboards, but ultimately, it comes down to interpreting the presented information. This is where Davis AI for exploratory analytics can make all the difference.

Davis AI can help you expand your dashboards and dive deeper into your available data to extract additional information. Our customers value the nearly unlimited possibilities for querying and joining data on the Dynatrace platform, with the option of instant, real-time visualization of query results. Whether you’re an expert or an occasional user, our recently launched Davis CoPilot will enable you to get instant results without the need to write complex queries yourself. Have a look at our recent Davis CoPilot blog post for more information and practical use cases.

If you’ve already created your dashboards, now is the time to use Davis AI to identify anomalies or predict future trends without restricting use cases.

Leverage Davis AI for anomaly detection and instant insights

“My chart shows a peak at 8:00 AM. Do I need to investigate this further?” You might be regularly confronted with this or similar questions. Davis AI machine learning capabilities will help you identify actual anomalies within seconds, enabling you to focus resources on issues that matter.

Based on your requirements, you can select one of three approaches for Davis AI anomaly detection directly from any time series chart:

• Auto-Adaptive Threshold: This dynamic, machine-learning-driven approach automatically adjusts reference thresholds based on a rolling seven-day analysis, continuously adapting to changes in metric behavior over time. For example, if you’re monitoring network traffic and the average over the past 7 days is 500 Mbps, the threshold will adapt to this baseline. An anomaly will be identified if traffic suddenly drops below 200 Mbps or above 800 Mbps, helping you identify unusual spikes or drops.
• Seasonal Baseline: Ideal for metrics with predictable seasonal patterns, this option leverages Davis AI to create a confidence band based on historical data, accounting for expected variations. For instance, in a web shop, sales might vary by day of the week. Using a seasonal baseline, you can monitor sales performance based on the past fourteen days. An anomaly is identified if sales on a Friday are significantly lower than on previous Fridays, indicating a potential issue.
• Static Threshold: This approach defines a fixed threshold suitable for well-known processes or when specific threshold values are critical. For example, if you have an SLA guaranteeing 95% uptime, you can set a static threshold to alert you whenever uptime drops below this value, ensuring you meet your service commitments.

Davis AI is particularly powerful because it can be applied to any numeric time series chart independently of data source or use case.

The following example will monitor an end-to-end order flow utilizing business events displayed on a Dynatrace dashboard. By leveraging Davis AI anomaly detection, we can identify potentially fraudulent behavior by activating anomaly detection on the Average order size chart. As shown in the chart below on the lower left, most values fall within the band of acceptable response time (highlighted in green), with only one spike occurring at 5:00 AM. Since this spike was outside the expected range, an anomaly was identified.

• Application Observability: Identify unexpected error rate increases in application performance, helping pinpoint and resolve issues quickly.
• Digital Experience Management: Monitor user interaction patterns to spot anomalies in website or app performance that could affect user experience, such as slow page load times.
• FinOps: Track irregularities in cloud spending or resource usage, enabling cost optimization and preventing budget overruns.

Forecasting: Visualize trends directly on your charts with Davis AI

Davis AI forecast analysis predicts future numeric values of any time series. It can even process external datasets or the results of any data query if it can be displayed as a numeric time series, such as occurrences over time.

The forecast is created instantly, even for large data sets, and updates dynamically whenever filter settings are changed.

In application performance management, acting with foresight is paramount. Maintaining reliability and scalability requires a good grasp of resource management; predicting future demands helps prevent resource shortages, avoid over-provisioning, and maintain cost efficiency.

On this SRE dashboard, we utilize Davis AI to forecast and visualize future resource utilization:

Other potential applications for forecasting include:

• Kubernetes: Forecasting helps dynamically scale Kubernetes clusters by predicting future resource needs. This ensures optimal resource utilization and cost efficiency. Forecasting can identify potential anomalies in node performance, helping to prevent issues before they impact the system.
• Business: Using information on past order volumes, businesses can predict future sales trends, helping to manage inventory levels and effectively plan marketing strategies.

AIOps: Utilize Davis AI to predict and prevent

Utilizing the Dynatrace AutomationEngine, Davis AI forecasting capabilities can even trigger automated actions. One of our customers’ SRE teams needed to increase disk space to avoid ongoing over- and under-provisioning, which was time-consuming and annoying. Now, with Davis AI forecasting capabilities, the target disk size is predicted automatically, and an automated task for disk resizing is triggered when necessary.

If you want to further explore the possibilities for prediction and prevention management with Dashboards, have a look at our example dashboard in the Dynatrace Playground.

Experience Davis AI in action

To experience the possibilities of Davis AI, look at this short introduction video by Andreas Grabner:

The post Better dashboarding with Dynatrace Davis AI: Instant meaningful insights appeared first on Dynatrace news.

In large enterprises, attributing IT costs to various cost centers, teams, or departments can be cumbersome and is typically only possible through significant manual overhead. Sometimes, introducing new IT solutions is delayed or canceled because a single business unit can’t manage the operating costs alone, and per-department cost insights that could facilitate cost sharing aren’t available.

In scenarios like these, automated and precise cost allocation can make a huge difference. Cost Allocation also unlocks new possibilities for strategic IT management, empowering you to align IT spending with your business priorities and serving as a fundamental prerequisite for adopting FinOps practices.

FinOps, short for Financial Operations, is a methodology combining finance, technology, and business teams to optimize cloud spending and maximize value in cloud environments. Costs and their origin are transparent, and teams are fully accountable for the efficient usage of cloud resources.

With the addition of the new Cost Allocation feature, the Dynatrace Platform Subscription now enables the application of FinOps, providing detailed cost transparency in near real-time (data is updated every 15 minutes), which is paramount to taking your strategic IT management to the next level.

Automatically allocate costs to teams, departments, or apps for full cost-transparency

In recent years, the Dynatrace platform expanded with many innovative features covering various use cases, from business insights to software delivery. These enhancements enable you to extract more value from your data, leading to wider adoption across enterprise departments. As Dynatrace now powers many different teams, the Cost Allocation feature helps you better control and prioritize your internal spending.

Incurred usage can be tagged at its origin based on your unique company structure. Also known as “chargeback” or “showback,” this functionality enables you to align every aspect of IT expenditure with your organizational framework, as you can now pinpoint exactly where and when costs occur within your organization.

This gives you a better understanding of financial impact and allows for granular strategic decision-making.

New insights into cloud spend enable strategic prioritization and business alignment

Dynatrace Cost Allocation is a groundbreaking upgrade for your cost management that provides many benefits:

• Business alignment: Cost Allocation ensures that every dollar you spend on IT resources is directly linked to your business priorities.
• Enhanced cost transparency: Enabling detailed tracking and reporting of expenses across various departments and products gives unparalleled visibility into IT costs. This granular level of transparency helps identify cost drivers, monitor usage patterns, and uncover opportunities for cost savings.
• Increased budget control: Cost Allocation empowers organizations to clearly understand their current costs and resource usage for different cost centers and products.
• Better planning and forecasting: By analyzing historical data, organizations can forecast future spending and adjust their budgets, promoting a disciplined approach to IT financial planning.
• Easier Dynatrace rollout across organizations: DPS enhanced by Cost Allocation allows departments to extract value from the Dynatrace platform while only paying for what they need. By leveraging improvements in Identity and Access Management, admins can ensure that Dynatrace users only have access to the data they need to do their jobs.

Explore and visualize your cost data

Allocated costs are stored in the Dynatrace Grail™ data lakehouse, which enables you to utilize the entirety of the Dynatrace platform to analyze, explore, and visualize your data. Start with our downloadable dashboard and customize it to your needs.

Use Davis® AI for accurate forecasting or to automatically catch unexpected spending deviations. You can also set up tailored and automated alerts utilizing the Davis Anomaly Detection app. Our comprehensive suite of tools ensures that you can extract maximum value from your billing data, efficiently turning insights into action.

You can also create individual reports using Notebooks—or export your data as CSV—and share it with your financial teams for further processing.

Set up Cost Allocation

Implementing Dynatrace Cost Allocation is straightforward and can be tailored to fit the unique needs of any organization. The process involves configuring cost center and product fields, setting up an allow list for valid values within account management, and using Dynatrace’s powerful API to extract and analyze cost data.

Best practices include regularly reviewing cost allocation reports, ensuring all relevant expenses are captured accurately, and refining budget limits based on usage trends.

Head over to Dynatrace Documentation to learn more about how to set up cost allocation in your environment.

Conclusion

Dynatrace Cost Allocation is essential for enterprises that seek to align IT spending with business goals, achieve cost transparency, and maintain strict budget control. By leveraging cost allocation, organizations can optimize their IT investments, drive financial efficiency, and support their overarching business strategy.

With regular updates and comprehensive dashboards, businesses can maintain a clear view of their IT spending, ensuring accountability and fostering a culture of cost consciousness.

Get started with Cost Allocation

Existing Dynatrace customers with a Dynatrace Platform Subscription can integrate Cost Allocation into their IT management strategy anytime, achieving unparalleled transparency and budget control across critical areas. Read more to learn how to activate Cost Allocation in your environment, then download the ready-made Cost Allocation dashboard from our dedicated community user group and start monitoring your costs.

With the release of Dynatrace SaaS version 1.303, Cost Allocation is available for host monitoring, security protection, and security analytics. Support for additional capabilities will be added in the future. Our documentation provides more details and will help you better understand the existing limitations.

If you want to learn more about Cost Allocation and experience the functionality live, have a look at our Observability Lab episode with Andreas Grabner and Sophie Mayerwieser: Cloud Cost Transparency with Dynatrace fine-grained Cost Allocation.

The post Level up your strategic IT management with fully cost-transparent, fine-grained Dynatrace Cost Allocation appeared first on Dynatrace news.

Manage the complexity of authorization systems

Most modern authorization systems provide access management using Attribute-Based Access Control (ABAC). ABAC has several advantages:

• Enhanced security, providing granular control over access permissions, significantly reducing the risk of data breaches and unauthorized activities.
• High flexibility, adapting to dynamic environments and diverse user needs. It also supports scalability, making it suitable for organizations of all sizes.
• Meeting regulatory requirements by providing detailed access control policies.
• High granularity by segmenting resource and record-level data, ensuring that access decisions are precise and context-aware.
• Up-to-date security through dynamic authorization; access can be granted or revoked in real time based on changing attributes.

This level of flexibility does, however, bring increased complexity, meaning that implementing and managing ABAC can be time-consuming and resource-intensive. The system demands significant effort to design, manage, and maintain, especially as an organization’s needs evolve. Authorization must be continuously managed and adapted to the changing requirements of applications and enterprises.

To counteract this, Dynatrace introduced features to make it easy for admins to adopt and apply our security policies while enjoying the benefits of a highly customizable ABAC system.

Dynatrace introduces new default policies for reduced complexity

With the introduction of security policies, we provided the capability of default policies, which are managed by Dynatrace and work out of the box.

Default policies eliminate much of the hassle of configuring permissions and can easily be deployed. Default policies also ensure a consistent security baseline across all your users, minimizing the chance of security gaps.

Our original concept of default policies, which was launched back in 2022, was focused on service level. While this concept gave admins much control, it also required knowledge of our service model. Striving for greater simplicity, we took another approach to default policies, focusing only on the two most important access control use cases:

• Dynatrace platform access (Dynatrace access): Managing access to Dynatrace features
• Data monitoring access (Data access): Managing access to monitored data stored in Dynatrace

Dynatrace access policies cover classic and new features, providing a single entry point to manage access to the entire feature set of the Dynatrace platform. With the new release, there are three default access policies available:

• Standard User policy: Provides baseline access to Dynatrace (corresponds to the former, “AppEngine – User”)
• Pro User policy: Provides access to advanced features
• Admin User policy: Grants admin privileges and provides access to all features (corresponds to the former, “AppEngine – Admin”)

Data access policies manage access to the monitored data stored in your environment. Access policies for Dynatrace Grail™ data lakehouse are still available as service-related policies; they allow you to control access to the monitoring data on a per-data-source level, for example, logs and metrics.

All other default policies on the service level, for example, “AutomationEngine – User” access, are now marked as Legacy. This means that existing assignments for these policies remain valid, but they can’t be changed except for deletion. Also, no new policy assignments with Legacy policies are allowed.

Simple partition management through policy boundaries

In addition to security policies, admins can now apply policy boundaries, simplifying the management of partitions on the data level and enabling further re-usability. While policies define which features and data users can access, policy boundaries define where users can access those features and data.

Policy boundaries allow you to manage your business-specific access control conditions separately from your policies and apply your policies selectively to one or many policy-to-group mappings.

For more information, go to our IAM policy boundaries documentation.

Get started with our new security policies

1. Utilize the default groups: If you’re a new Dynatrace customer, we recommend that you utilize the default groups provisioned during account creation. This significantly reduces the effort required to manage user groups and permissions.
2. Utilize the default policies for new user groups: When creating new groups, utilize the Dynatrace default policies for baselining.
   • Dynatrace access policies: Decide which functionality your users require and apply the right Dynatrace access policy. Regular users can work with the Standard or Pro User policy; the Admin User policy should be reserved for admins only.
   • Data access policies: To manage data access, select the data sources your users should be able to see, such as logs, spans, metrics, and so on. Use the respective data access policies for these assignments.
3. Assign policy boundaries: When you need to restrict monitoring data access on a per-record basis or if you need to restrict the resources offered by Dynatrace platform services, define these conditions in your boundaries and apply them as part of your policy configuration. You can assign multiple boundaries to a single policy. The boundaries are automatically matched to the respective policy statements and restricted further.
4. Refine assigned policies with boundaries reflecting your record/resource partitions.
5. Create custom policies for advanced access scenarios not covered by the Dynatrace defaults. Be aware that creating custom policies requires additional maintenance effort to keep them current.Here is a list of use cases where custom policies can help you fulfill advanced access scenarios:

1. • Extend or restrict access defined by default policies by creating custom policies with ALLOW/DENY statements that tailor user access.
   • Template reusable policies to assign privileges at scale.
   • Create custom policies and assign them to the All-users group to establish a baseline of permissions for all users in your account.

Adopt the new Dynatrace security policies today

Go to Dynatrace Documentation for complete information about these enhancements to Dynatrace access management and how you can benefit from them. If you’re an existing customer and want to upgrade to the attribute-based access control system, check out our new guide, which will walk you through the process.

This blog post is part of our series on Tailored access management. If you’re interested in learning more about the Dynatrace approach to IAM, have a look at Part 1 and Part 2 of this blog series.

The post Tailored access management, Part 3: Simplified setup for enterprise-scale access management appeared first on Dynatrace news.

Take your monitoring, data exploration, and storytelling to the next level with outstanding data visualization

All your applications and underlying infrastructure produce vast volumes of data that you need to monitor or analyze for insights. Visualizations help to curate data into a form that is more accessible to understand, highlighting trends and outliers, gaps, clusters, or patterns. At a single glance, visualizations can raise questions that stimulate further exploration or indicate problems.

Each type of visualization tells a different story and is best suited for a particular use case. If you want your data to speak to its audience, you need a comprehensive toolkit of visualizations and customization options. Good visualizations are not just static, unintelligent data presentations; they enable interaction and ideally serve as a starting point for subsequent analysis.

Dynatrace unified analytics capabilities for observability are top-of-the-class (Gartner Magic Quadrant 2024), enabling you to query and analyze all your observability data across your enterprise. The Dynatrace Notebooks and Dashboards apps are the perfect starting point for visualizing and understanding your data for monitoring or in-depth analysis.

Over the last year, we introduced many new functionalities and updated our visual presentation to provide you with an all-new experience:

• Optimized for exploring large data sets: We’ve optimized our entire interface, components, and visualizations to present large volumes of data while providing all the required flexibility.
• Visualize with a single click: Even inexperienced users can visualize data sets and create graphs in seconds.
• Broad range of visualizations: Our curated catalog provides numerous visualization types and hundreds of customization options, including the newly added honeycomb and histogram visualizations.
• Interact with your data: We integrated additional data interaction methods to provide more information immediately.
• Quick analysis with Davis CoPilot™: Explore your data through natural language by translating your conversational prompts directly into DQL queries.

Now, let’s introduce you to our two newest entries to our visualization catalog and tell you about the great things you can do with them.

New: identify hotspots with the honeycomb visualization

Honeycombs are great for visualizing health in complex and distributed systems, enabling you to visualize countless entities effectively and at scale. They have become a quasi-standard in the industry, especially for infrastructure monitoring visualizations.

The new honeycomb visualization in Dynatrace enhances your health dashboards and offers many customization options to tailor it to your needs. For example, it supports string and numerical values, enabling a multitude of different use cases. There are many practical applications of honeycombs; here is a small sample of just a few of them:

• Problem visualization: The new, ready-made dashboard for the Problems app features two honeycomb visualizations. At one glance, you see which entities are particularly affected by problems, and you can also identify the blast radius of a single problem to understand how many entities have been affected. Have a look at them on our Dynatrace Playground.
• Infrastructure health: A honeycomb chart is often used to visualize infrastructure health. You can use it to visualize CPU utilization across your hosts, disk space used, server-side response time, web request/service failure rates, or any other area where you need to spot outliers immediately.
• Service Level Objectives (SLO) tracking: Honeycomb charts can visualize SLOs, helping you monitor whether your services meet performance and reliability targets. Based on the color, you immediately see if any SLOs are off track. This can guide you in prioritizing issues that impact user experience.

How you get the best results with honeycombs

Honeycombs highlight hotspots that require attention. To achieve the best visual outcome, we recommend experimenting with the available customization options.

• Try different cell shapes. The honeycomb visualization also supports circles and square variants, allowing you to differentiate between use cases clearly.
• Use color coding to tell a story. Use different diverging and sequential color palettes to highlight patterns and insights in your data. The chart also supports conditional coloring for both string and numeric values.
• Min and max limits. Set an applicable, expected value range in the honeycomb visualization to ensure effective coloring and highlighting of hotspots and outliers. For example, set the value range for CPU consumption from 0% to 100%. In other use cases, you want to ensure a consistent zero-baseline (that is min = 0), but with an automatic scaling max value (max = auto).

Go to our documentation to learn more about implementing honeycomb visualizations on your dashboards or notebooks.

New: explore your data with histograms to identify patterns

The histogram chart is a crucial visualization for understanding the distribution patterns of values within a given dataset. It shows where the peaks of the distribution are, whether the distribution is skewed or symmetric, and whether there are any outliers.

While histograms look much like time-series bar charts, they’re different in that each bar represents a count (often termed frequency) of metric values. These bars are called bins or buckets; their width represents a value range. The height of the bar reflects the frequency or count of data points within a bucket.

The use cases and underlying metrics analyzed via histograms are extremely broad:

• Latency distribution: Histograms can show the distribution of request latencies, helping you understand how many requests fall into different latency buckets. This is useful for identifying performance bottlenecks and understanding the overall user experience.
• Resource utilization: Use histograms to visualize the distribution of CPU or memory usage across different instances or containers. This helps identify outliers and understand the overall resource consumption patterns.
• Distributed tracing: Histograms can analyze the response times of different endpoints or services, allowing you to pinpoint which parts of your system are slower and need optimization.
• User behavior tracking: Track user interactions, such as login or page load times, to understand how users are experiencing your application. This can help identify areas for improvement in user experience.

How you get the best results with histogram charts

Experiment with bucket sizes. Use DQL’s built-in range function, together with the summarize command, to bucketize your data. The choice of bin size has an inverse relationship with the number of bins. The larger the bin sizes, the fewer bins will be needed to cover the whole range of data. With a smaller bin size, you’ll get more bins.

It is worth taking some time to test out different bin sizes to see how the distribution looks in each one, then choose the best plot that represents the data. Try out different range sizes or bin ranges (“widths”) with your data set – doing so can help you identify distinct patterns in the data.

If you have too many bins, the data distribution will look rough, making it difficult to discern the signal from the noise. On the other hand, with too few bins, the histogram will lack the details needed to discern any helpful patterns from the data. Identify common distribution patterns such as bimodal, comb, edge peak, normal, skewed, and uniform.

Add split by parameter. This can help compare sub-distributions; however, it is ideally limited to only two sub-divisions, such as A vs. B, North vs. South, Open vs. Closed, Male vs. Female, etc.

If you want to learn more about how to best use histograms for OTel observability, check out Mikko Viitanen’s OpenTelemetry histograms blog post. In this post, you’ll learn how to define and monitor service-level objectives with histograms that can be used to set up alerts.

After introducing the new visualizations, we will now look at our new custom settings.

Optimize your visualizations with many new configuration options

We elevated the handling of visualization settings across Dashboards and Notebooks in three powerful ways:

1. We extended the customization options for all data visualizations by offering an additional 35+ configuration options, such as custom column types in the table, so you can better tailor your visualizations to your specific requirements.
2. We improved the usability of all visualization settings by introducing new unified UI controls across both apps. Now, it’s even easier for users to customize visualizations as they see fit for any use case.
3. We introduced a visualization settings search so that you can instantly search all settings and find the exact configuration or customization option you’re looking for.

Get more details immediately

In our recent release, we added more functionality to enable you to interact with your data. You can now zoom into your data or pan left and right in all time-series visualizations. This allows you to zoom in on a particular data set, see underlying details, or change the displayed data altogether. This allows you to dive deeper into your data anytime without needing to modify/rewrite your original query.

Taking this interaction a step further, in Dashboards, if you zoom in on one visualization, it will automatically apply to all other visualizations on the same dashboard.

The functionality is automatically available in all time-series charts in the Dashboards and Notebook apps.

Zoom-in

Click and drag any time series chart in your Dashboard or Notebook to zoom in on your data. The interaction will re-fetch data for the selected timeframe (in most cases, with a more fine-grained interval).

Alternatively, you can zoom in and out with the integrated chart toolbar, located in the top right corner of the chart, keyboard shortcuts, or touch gestures.

In Dashboards, the zoom interaction adapts the timeframe for the current chart and updates the entire dashboard, automatically synchronizing all other tiles and visualizations.

^{Figure 5. Zoom-in}

Panning

You can click and drag the chart’s x-axis to pan it to the left or right while maintaining the current zoom level. Alternatively, you can pan left and right using the middle mouse button, activating the chart’s pan mode (via the integrated chart toolbar), keyboard shortcuts, or touch gestures.

Keyboard accessibility

If you prefer interacting with your visualizations via the keyboard, we also have you covered: all interactions are also available via the keyboard. Switch between modes with “e” to explore your data or “p” to pan the chart left and right. Holding down the “CMD/CTRL” key while pressing “arrow up” or “arrow down” will let you zoom in or out of the chart. Pressing “r” will quickly let you reset all the zoom and pan changes.

What’s next

World map and heatmap visualization

We constantly exchange with our community and add further visualizations to our curated catalog where it makes sense. We’re currently working on introducing multiple world map visualizations and a heatmap, which you can expect to be released in the upcoming quarters.

Synchronized crosshair

In addition to the interactions described above, we will soon support automatically synchronizing all crosshairs across all time-series charts. That way, you can compare multiple charts more easily, regardless of the metric or time span.

Try our new visualizations now

If you’re an existing Dynatrace customer, visit your Dashboards app and check out our ready-made dashboards. Our new Getting Started document explains how to create and customize honeycomb and histogram visualizations. Also, have a look at our new Problems Dashboard, which you can access and download directly from the Dynatrace Playground.

To learn more about how data visualizations can enhance your app insights, check out our latest episode of Inside Dynatrace Apps with Mikele Hasson and Penny Scully

The post Next-level interaction and customization of data visualizations in Dynatrace Dashboards and Notebooks appeared first on Dynatrace news.