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.

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.

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.

Enriching observability data with additional context means improved data quality, which leads to better decision-making and faster troubleshooting. Instead of switching to an external data source and searching for a specific identifier across multiple documents, you now gain immediate insights at query time, effectively streamlining your work.

In this blog post, you’ll learn how to ingest lookup data and use it to effortlessly enrich your observability data. Practical use cases outline scenarios in which lookup data improves user workflows and makes root cause analysis and troubleshooting more efficient.

How to ingest lookup data

Lookup data files can be uploaded in formats such as CSV, JSON, or XML. You can upload data files using Workflows, via API, or by creating your own custom app. Once ingested, you can query lookup data just like any other Grail data, using Dynatrace Query Language (DQL) commands like lookup and join, or built-in Dynatrace® Apps like Dashboards, Notebooks, and Security Investigator for exploratory analytics.

In addition to an uploaded data file, you also need to provide a parse pattern written in Dynatrace Pattern Language (DPL) that defines the structure of the lookup data.

Once uploaded, you can access lookup tables via the load command. Be aware that files are organized in a directory-like structure in Grail. To make it easier to find stored files, we’ve introduced autocomplete functionality. Just start typing and jump directly to the respective file.

To learn more about supported file types, available attributes for data ingest, or the structure of parse patterns, please have a look at our documentation.

Practical use cases

Populating lookup data is a fantastic choice for enriching data with additional context in several scenarios:

• Mapping error codes in your logs to readable text for streamlined troubleshooting,
• Enriching IP addresses or IDs with respective account names to convert meaningless identifiers into meaningful qualifiers that speed up triage and root cause analysis.
• Accelerating security investigations with allow lists for security data.

Enrich your data with business context

Imagine that your system’s business-relevant events logged in Grail contain product IDs, and you’d like to enrich the IDs with the vendor’s name and some additional information from an external source.

This can easily be done with lookup tables by ingesting data containing the product and vendor information. In the example below, we use the product ID as the lookup field and enrich the business events with the mapped vendor values from the lookup table.

fetch bizevents
| lookup [ load "/lookups/vendorlist" ],
    sourceField: product.id,
    lookupField: product.id

Improved insights when working with security data

In another use case, imagine a security analyst is tasked with finding suspicious login attempts to your company’s network outside of business hours. Let’s assume corporate policy allows IT engineers to work from home any day, but that is not the case for accountants. The security analyst wants to understand which usernames belong to which role. Doing this manually would mean spending considerable time cross-referencing employees with their respective roles and manually creating filters based on usernames.

Creating a lookup table containing employees’ usernames and roles could significantly streamline this work, allowing the analyst to use external data to filter and summarize more accurate results.

Filtering for malicious IP addresses

Suppose your security analyst has obtained a list of fraudulent IP addresses from a threat intelligence feed that tracks malicious IP activity. These IP addresses are associated with spam, malware, botnets, or other malicious activities that expose your applications to potential threats.

The security analyst can now store this suspicious IP list as lookup data in Grail, update it whenever necessary, use it to detect and flag requests from any listed IP addresses, and leverage the data for further analysis in Security Investigator.

Flag TOR exit nodes

Going a step further, your security analyst can identify, flag, and track requests from TOR networks. TOR is an anonymizer that hides your tracks on the internet. By rerouting your internet activity via at least three other nodes before reaching your website, the TOR network obscures where requests originate, allowing bad actors to hide their identity and explore the internet with malicious intent.

The analyst creates a lookup table and populates it regularly with the latest list of TOR exit nodes. This data is used for further analysis, for example, in Security Investigator to detect login attempts that originate from TOR.

To utilize the Dynatrace® platform’s full power and set the TOR data in context, the analyst automates the fetching, writing, and uploading of the list of IP addresses using Workflows and visualizes the data with Dashboards.

What’s next?

Lookup tables provide a method to efficiently add context to any type of data stored in Grail. They can be used to integrate operational and transactional data, supporting your users in their day-to-day lives.

Stay tuned for further updates, such as improving our existing Snowflake Workflow Connector by adding capabilities to create and manage lookup tables, and using Security Investigator to create new lookup tables or view and filter existing tables.

Are you interested in trying out lookup tables in your own environment? This new capability is available as a public preview for all customers running the latest version of Dynatrace SaaS with an active Dynatrace Platform Subscription (DPS). It is super simple to activate; head over to our documentation to learn how.

The post Enrich your Dynatrace data with the newly introduced lookup tables appeared first on Dynatrace news.

Harness geographical insights from your data

With the new world map data visualizations, you can easily bring datasets into a geographical context by leveraging geospatial attributes. From Apdex scores by country, sales by branch location, and user errors by region, to global traceroutes, delivery vehicle tracking, and LLM usage by location, we’ve got you covered. All world map visualizations are world-view aware, adapting to different geopolitical perspectives and regional boundaries, with no additional configuration required.

To support a wide range of geospatial use cases, we introduced four distinct map types, each focusing on specific “stories” that can be told:

• Dot distribution: Marks precise locations (for example, real users, store locations, delivery vehicles, cruise ships).
• Bubble: Visualizes volume or intensity at specific points (for example, traffic, error counts).
• Connection: Shows relationships or flows between locations (for example, service-to-service traffic, traceroutes).
• Choropleth: Highlights aggregated metrics by country or region (for example, showing total revenue by country to quickly spot which regions are driving the most sales).

How to use world-map data visualizations effectively

World maps are among the most powerful and unique visualizations for exploring data from a geographic perspective. They make spatial patterns and regional insights immediately clear. What might be difficult to spot in a table often becomes instantly visible in a sequentially colored choropleth map, helping you uncover trends tied to real-world locations.

For the best possible results:

• Choose the right map type for your data.
  • Use a choropleth map for aggregated data by country or region.
  • Use dot distribution or bubble maps for precise location-based data points.
  • Use connection maps to visualize routes, flows, or relationships between locations.
• Tailor color schemes and granularity to your audience. For example, executive dashboards may benefit from simplified, high-level views, while operational dashboards might require more detailed, granular data.
• Leverage dashboard variables (for example, region, service group, or environment) to dynamically filter and update the map in real time, enabling more interactive and context-aware exploration.

Track key thresholds with gauge visualizations

Gauge charts are a powerful way to visualize real-time metrics against thresholds, providing immediate visual feedback on whether you’re operating within acceptable limits. Gauge charts are perfect for tracking key performance indicators (KPIs) like response times, error rates, or throughput. They’re also well-suited for visualizing SLOs, making it easy to see how close you are to breaching targets, and for monitoring LLM performance, visualizing token usage, model load, or latency per prompt in AI Observability use cases. In business analytics, gauge charts can be used to represent conversion rates, revenue goals, or customer satisfaction scores.

How to use gauge charts effectively

Select a gauge chart when you need to display a single metric and compare its current value against one or more thresholds.

When configuring a gauge chart, don’t forget to:

• Define meaningful minimum and maximum values to ensure the gauge data visualization accurately reflects the expected range of the metric.
• Apply custom color coding to define threshold ranges, for example, use green for “healthy,” yellow for “warning,” and red for “critical” states. This enhances visual clarity and helps users quickly interpret a metric’s status.
• Pair gauge charts with time series visualizations to provide both real-time status and historical context, helping users understand not just the current state, but how it’s evolved over time.

Unlock hidden patterns with enhanced heatmaps

Traditionally, heatmaps were limited to showing how a metric changes over time. With our new enhanced heatmap, that constraint is gone. You can now combine any axis type, time series, numerical, or categorical, unlocking a much broader range of use cases and analytical depth.

This flexibility allows you to visualize complex relationships across dimensions, such as service vs. error code, user segment vs. response time, or model version vs. token usage. Whether you’re analyzing RUM data, Application Security alerts, or LLM performance, the enhanced heatmap data visualization helps uncover patterns and hotspots that were previously hidden.

How to use heatmap visualizations effectively

Use a heatmap to explore relationships across multiple dimensions, especially when those dimensions include a mix of value types.

Heatmaps are ideal for uncovering patterns, correlations, and anomalies in complex datasets. They’re particularly useful for comparing metrics, enabling analysis that goes far beyond traditional time-based heatmaps. In the example below, the heatmap visualizes how request durations are distributed over time: darker areas reveal when and where high volumes of similar-duration requests occur, helping you spot performance trends and anomalies instantly.

• Choose meaningful dimensions: Combine time, numerical, and categorical axes in ways that reveal useful patterns, for example, service vs. error code, region vs. response time, or model version vs. token usage.
• Use consistent binning and grouping: Aggregate your data in a way that supports meaningful comparisons. For example, group timestamps into hourly or daily intervals, or bucket numerical values into ranges.
• Apply intuitive color palettes: Use color gradients that clearly communicate intensity or severity, such as diverging color palettes to highlight differences around a midpoint or sequential color palettes to represent gradual changes in intensity, ensuring the colors align with the data’s structure and purpose.
• Avoid overcrowding by using dashboard variables and filters: Heatmaps can become hard to interpret when too many values are shown at once. Use dashboard variables (for example, service, region, environment) and filters to dynamically narrow the scope, focusing on what’s relevant without overwhelming the user.

Try the new data visualizations

Explore the new visualizations directly in Dashboards or Notebooks.

• See applied LLM Observability use cases for these data visualizations in our latest blog post covering all new features in the Dashboards app.
• Use the Dynatrace Playground to test out visualizations without touching your production environment.
• If you’re interested in previous additions to our data visualization catalog, such as honeycomb or histogram, have a look at our previous blog post.

The post Tell data-driven stories with new world map, gauge, and heatmap data visualizations appeared first on Dynatrace news.

When you’re working with complex, multi-layered data, pinpointing the root cause of an issue or identifying anomalies can feel like trying to find a flickering light in a city skyline. Effective troubleshooting demands a deep understanding of data structures, filters, and query logic. But what happens when you’re staring at a mountain of logs or metrics and don’t even know what to look for? For instance, imagine you’re investigating a sudden spike in error rates across your application. Without knowing which service triggered the cascade or how to filter the noise, you’re left guessing where to begin.

With the introduction of deep search functionality in Grail, we’ve introduced a new way to cut through the noise of complex data. You can now explore data effortlessly without needing to understand every single layer of complexity in your data structure.

Investigating data is a time-consuming process

Difficult data investigations can be taxing. Examining data takes too long, and probing for issues is tricky for those who don’t know the complexities of the data structure. In the query example below, taken before the introduction of DQL search, we attempt to filter within spans where any event sent from an Oracle database contains the phrase “error”.

Search within complex structures

Grail’s unique data warping technology allows for index-free, schema-on-read, high-performance queries, enabling you to flexibly analyze diverse datasets. While Grail has long been capable of dynamically interpreting complex data structures at query time, with the addition of the DQL Search command, you can now deep dive into your metrics, logs, traces, and other data stored in Grail in a way more agile and intuitive way.

Simplified string-based filtering across multiple fields

You can now search across vast and complex data sets without needing to understand the underlying structure. By leveraging string-based search, the system offers intuitive exploration of deeply nested data—no manual filters or query syntax are required. This approach eliminates the traditional barriers of schema knowledge and filter construction, making data investigation accessible to everyone. (See Figure 2 below.)

Surface the needle in the haystack faster

You can search across all fields, not just indexed or predefined ones, making it easy to surface any data without needing to pre-tag or preprocess it. DQL search is optimized to be highly performant, even with terabytes of data.

Search in nested structures

Finding relevant data within nested elements or arrays is cumbersome, requiring a lot of effort to ensure you don’t exclude necessary parts of the data structure. With the new DQL Search command, you can search across complex data structures, including nested elements and arrays, to find exactly what you need.

Imagine a DevOps engineer troubleshooting a failed deployment in a development environment. Suspecting a misconfiguration or runtime error, the engineer needs to find traces containing the term “exception”—buried deep within the span.events array of nested records. The system scans across all nested fields and surfaces relevant spans instantly—saving time, reducing friction, and accelerating root cause analysis.

Now, consider another example with Dynatrace Security Investigator. You’re investigating a security incident in your Amazon cloud environment. You need to track a specific event from your AWS CloudFront logs, and you have the CloudTrail event ID value. You have no idea where to find the event ID. It could be buried in the content, tucked away in header values, or stored in an obscure field. The DQL Search command empowers you to search across all fields instantly—no filters, no field-mapping, just fast, accurate results when you need them the most.

As simple as using a search bar, inside DQL

Experience the flexibility and power of exploratory analytics in Dynatrace without worrying about indexes or schemas. The DQL Search command allows for deep, detailed investigations while maintaining simplicity, making it accessible to a wider range of users.

The post Deep Search: Transform your data exploration and investigation with Dynatrace Grail appeared first on Dynatrace news.

Deploying and safeguarding software services has become increasingly complex despite numerous innovations, such as containers, Kubernetes, and platform engineering. Recent global IT outages, such as the CrowdStrike incident, remind us how dependent society is on software that works perfectly.

Organizations strive to strike a delicate balance between cost, time to market, and innovation. This challenge is more pressing than ever as businesses seek to stay competitive while ensuring their software remains robust and secure.

This necessitates a comprehensive platform that empowers enterprises to understand IT and software within the broader context of their business operations, giving them confidence that their software and IT infrastructure are reliable.

Scale with confidence: Leverage AI for instant insights and preventive operations

Using Dynatrace, Operations, SRE, and DevOps teams can scale efficiently while maintaining software quality and ensuring security and reliability. Its AI-driven exploratory analytics help organizations navigate modern software deployment complexities, quickly identify issues before they arise, shorten remediation journeys, and enable preventive operations.

We’ve added numerous enhancements to our platform, leveraging advanced AI and automation for smarter software observability.

In this blog post, we show you how to

• Get AI-driven insights directly on your operations dashboards
• Improve MTTR with AI-assisted problem analysis and logs and traces in context
• Leverage Gen AI through Davis CoPilot to get insights into root causes
• Automate remediation of AI-detected problems with simple workflows
• Adopt Preventive Operations with AI forecasting and automated action

Get AI-driven insights directly on your operations dashboards

A high-level, customizable view of your data is crucial in modern software operations. Dynatrace Dashboards, powered by Grail™ data lakehouse and Davis® AI, offer precisely that. They provide a comprehensive overview, seamlessly integrating health and problem-related information into a single view. You can chart your topology across data silos alongside all alerts, events, and problems using honeycomb tiles, which offer convenient drill-downs into the problem-debugging user flow.

Dynatrace ensures that context is seamlessly integrated into the platform, thus simplifying complexity for you as a user when analyzing issues and allowing you to focus on what truly matters. AI-driven analytics transform data analysis, making it faster and easier to uncover insights and act. This approach not only improves user experiences, it ensures that critical insights are accessible to both experts and novices. By simplifying remediation journeys and extending features to more user groups, Dynatrace enables results across all teams.

When a truly important issue stands out, the next step is refinement. With a few clicks, you can segment and filter your data to focus on specific applications, assignment groups, or regions. Directly mapping and surfacing ownership information within data segments accelerates incident assignment notifications and triggers automatic remediations.

If you see an issue or need to look closely at a specific application where an issue was identified, simply select the element to be seamlessly directed to the Problems app. There, you can dig deeper while continuing to focus on your selected segment. This tight integration, following a golden thread of insights, ensures that you’re more productive. To experience the possibilities of AI-empowered dashboards, try our example dashboard on the Dynatrace Playground.

Improve MTTR with AI-assisted problem analysis, logs, and traces in context

The Problems app delivers opinionated AI-assisted problem analysis optimized for Operations and Site Reliability Engineers (SREs) and developers. According to IDC, guiding users visually and automatically surfacing all critical details enables a 56% faster mean time to repair (MTTR) for critical incidents.

When a large-scale incident occurs, follow the red flag that Davis AI uses to identify the root cause, pinpoint all relevant details, and visually reproduce the details in charts, highlighting the affected deployment.

Besides identifying the root cause, Davis AI also automatically connects all relevant log lines. Logs are invaluable for identifying further insights and detecting fundamental flaws, such as process crashes or exceptions. With a single click in Problems, all incident logs are surfaced automatically. But we don’t stop there, Dynatrace also seamlessly integrates relevant trace data, offering full visibility into even complex, microservices-based architectures.

By providing these end-to-end insights, Dynatrace and Davis AI empower SREs, developers, and architects to quickly dive deep into an incident’s details, including all relevant logs and traces. Using this context, they can effectively focus on fixing and remediating code-level issues, significantly improving MTTR, and ensuring that critical incidents are resolved swiftly and efficiently.

Leverage GenAI via Davis CoPilot for insights into root causes

Dynatrace offers precision tools for domain experts to solve complex problems and dig deeper into their data. While product owners often focus on the intricate technical details of an incident, they often prefer a quick summary of what happened and what caused it. The soon-to-be-globally available Davis CoPilot™ bridges this gap by summarizing problems and their root causes and suggesting remediation steps based on these insights.

You’re not limited to one problem; Davis CoPilot can simultaneously analyze multiple problems, draw conclusions about their relationships, identify the common root cause, and propose corrective steps. Instead of relying on a team of experts and waiting hours for insights, Davis CoPilot helps you identify similarities and draw relevant conclusions independently and efficiently.

The use of generative AI adds significant value by augmenting Dynatrace-detected technical root causes with knowledge from the global tech community. Generative AI can access and synthesize vast amounts of information from various sources, providing a broader context and deeper insights. This ensures that your teams benefit from the latest advancements and solutions, enhancing their ability to resolve issues effectively and efficiently.

Automate remediation of AI-detected problems with simple workflows

To automatically remediate Davis AI-detected problems, Dynatrace leverages powerful Workflows. Dynatrace workflows can be triggered by any problem or alerting event, automating domain-specific tasks to take remedial actions.

For example, workflows can scale up capacity to adapt to demand or automatically restart a service in case of a crash. With a large catalog of available workflow actions, you can react efficiently to AI-detected problems, reducing mean time to repair (MTTR) by automatically remediating issues.

But you can do much more with it: The recently introduced Simple Workflows, which are included in your Dynatrace subscription with no extra cost, offer greater flexibility and power than standard notifications. You can use the same mechanisms and trigger types to notify your developer team via Slack, create a JIRA issue, or send a PagerDuty alert.

This ensures that your operations, SRE, and DevOps teams can focus on more strategic tasks while the system handles routine problem resolutions. Automation enhances operational efficiency and ensures that your systems remain robust and reliable, even in the face of unexpected issues.

Adopt Preventive Operations with AI forecasting and automated action

Going beyond reactive problem detection, analysis, and remediation, Dynatrace can also leverage predictive AI to anticipate and avoid critical situations before they occur. Using Davis AI forecast, you can easily predict future capacity demands. Combining this knowledge with workflows allows you to take proactive measures to ensure system stability and performance.

Let’s have a look at a concrete example:

It’s easy to predict key indicators of your application, such as order levels or service request counts. Once load and demand rise and Davis AI identifies a potential future issue in your infrastructure setup, Davis CoPilot can automatically generate an updated Kubernetes configuration script for you and automatically upscale the environment to meet future demand. This ensures that your system scales appropriately to handle the anticipated demand, preventing incidents before they occur and eliminating the need to generate a problem.

That’s what we call Preventive Operations. Instead of sending an alert and notifying people, Dynatrace simply fixes the issue. According to Gartner’s Analytics Maturity Model, using predictive AI can significantly reduce the likelihood of incidents by taking preemptive action and remediation.

Start using Davis AI to analyze your environments and predict and address potential issues in advance. This will empower your teams to avoid potential problems and ensure a smooth, uninterrupted user experience.

Tackle business challenges with confidence

Ensure your software runs securely and reliably with Dynatrace and Davis AI.

Dynatrace and Davis AI support you by running your software securely and reliably. This includes advanced root cause analysis, deep insights into detected issues, and corrective actions—whether manual or automatic—to prevent outages before they occur.

Get started

For more information, have a look at our documentation or explore the available resources on the Dynatrace Playground to experience some of these enhancements first-hand:

• Investigate our Problems dashboard or have a look at the Problems app on the Dynatrace Playground
• Experience the Davis AI forecasting capabilities embedded in Dashboards
• Watch a step-by-step video and learn how to proactively scale out your Kubernetes environment
• Dig deeper into our documentation for Davis CoPilot, Problems, or Simple Workflows

The post Powerful exploratory analytics for AI-driven insights appeared first on Dynatrace news.

When we launched the new Dynatrace experience, we introduced major updates to the platform, including Grail™, our innovative data lakehouse unifying observability, security, and business data, and Dynatrace Query Language (DQL) for accessing and exploring unified data. While Grail and DQL opened up nearly limitless possibilities for data exploration, mastering DQL was necessary to fully leverage the power of Grail. Our latest enhancements to the Dynatrace Dashboards and Notebooks apps make learning DQL optional in your day-to-day work, speeding up your troubleshooting and optimization tasks.

In this blog post, we look at these enhancements, exploring methods for monitoring your Kubernetes environment and showcasing how modern dashboards can transform your data. Furthermore, we illustrate how these methods work seamlessly with Dashboards and Notebooks to enhance their effectiveness.

The many paths to building a dashboard or notebook

Getting started with the new Dashboards is now easier than ever, offering unprecedented ease and capabilities for exploring your data. We’ve not only improved how you interact with data in dashboards and notebooks, we also enhanced the way that underlying data can be shared across apps. These updates expand your options for exploration and creation, helping you to build your dashboards and notebooks quicker and more intuitively.

You can now:

• Intuitive data access with Davis CoPilot AI assistant
• Kickstart your creation journey using ready-made dashboards
• Accelerate your data exploration with seamless integration between apps
• Start from scratch with the new Explore interface
• Search for known metrics from anywhere

Let’s look at each of these paths through an end-to-end use case focused on Kubernetes monitoring.

Kickstart your creation journey using ready-made dashboards and notebooks

Creating dashboards and notebooks from scratch can take time, particularly when figuring out available data and how to best use it. Ready-made dashboards and notebooks address this concern by offering pre-configured data visualizations and filters designed for common scenarios like troubleshooting and optimization.

These ready-made dashboards offer your platform engineers, who oversee Kubernetes environments, immediate and comprehensive data visibility. This allows platform engineers to focus on high-value tasks like resolving issues and optimizing performance rather than spending time on data discovery and exploration.

Kickstarting the dashboard creation process is, however, just one advantage of ready-made dashboards. Let’s assume you’re already using the new Kubernetes app, which offers a comprehensive overview of your Kubernetes environments and their telemetry. There are cases where more flexible data presentation is needed. Our new ready-made dashboards for Kubernetes not only provide instant insights into your clusters, nodes, workloads, or pods but also enable you to extend and customize the data shown in the Kubernetes app, leveraging the context-rich data from Dynatrace Grail. So, for example, if you need to seamlessly integrate metrics with logs for your workloads, you can create a customized view based on the pre-configured dashboard that consolidates all critical signals in one place, which is particularly essential for troubleshooting.

Finding ready-made dashboards is straightforward. Navigate to the list of dashboards and set the filter at the top left to Ready-made. Select the title of any dashboard that interests you, or use the search bar to narrow down the results.

Accelerate data exploration with seamless integration between apps

In developing the new Dynatrace experience, our goal was to integrate apps seamlessly by sharing the context when navigating between them (known as “intent”), much like sharing a photo from your smartphone to social media. This approach acknowledges that in any organization, software doesn’t work in isolation; boundaries and responsibilities are often blurred. This is even more true for critical scenarios like troubleshooting, which often requires more than the capabilities of a single person or app.

Let’s make this more tangible by using the Kubernetes cluster dashboard and demonstrating how this concept helps you to:

• Seamlessly navigate between apps while maintaining context.
• Effortlessly explore data in Dynatrace and create dashboards from it.

When working with the Kubernetes cluster dashboard, you have two options for digging deeper into further analysis, both using the Kubernetes app. You can use dynamic markdown links, which include the values of the actual dashboard variables, or you can utilize the open-with feature (the “intent” concept), which uses the actual context of the dashboard tile you’re viewing. With this latter approach, you even have the choice of passing a single value (Open field with) or all underlying data (Open record with) for the respective element (row, series, cells, etc.) when navigating to another app.

Next, let’s use the Kubernetes app to investigate more metrics. The intent concept and the open with feature can also be applied in reverse to include data or specific visualizations from an app on a particular dashboard. An example of this is shown in the video above, where we incorporated network-related metrics into the Kubernetes cluster dashboard.

Start from scratch with the new Explore interface for metrics in Dashboards and Notebooks

Once you’ve learned how to monitor your Kubernetes cluster using a ready-made dashboard and extending it with context from other apps, the next step is understanding how to create and extend such dashboards using the Dashboards or Notebooks app.

Exploring and adding metrics from scratch

Let’s revisit our example from the last chapter and add the same Kubernetes network metrics, this time by using the new Explore metric interface that allows you to:

• Browse and add multiple metrics to a single tile
• Apply basic commands such as aggregation, filter, and split

• Use expressions to do calculations based on previously added metrics

The revised Explore interface, as shown in the clip above, now includes logs, metrics, events and business events, offering an improved filtering experience that enables you to:

• Type ahead to add, edit, or remove available filters
• Control how filters are applied via a rich set of operators (=, !=, in, not in, >=, <=, >, <)
• Place wildcards before and after your filter values to automatically generate the best matching DQL when using startsWith, endsWith, or contains.
• Control how filters are combined with logical operators, such as AND or OR
• Easily filter entities by ID, name, or tags in the web UI
• Get suggestions for metric values and entities (IDs, names, tags) for all data types

Blend metrics with data from Explore logs for a more comprehensive view to start log analysis

With the enhanced Explore Logs interface, retrieving and viewing logs from your Kubernetes workloads is straightforward. By incorporating a new tile, you can integrate these logs into your dashboard along with key metrics, such as the new Kubernetes network metrics we added earlier.

Leverage dashboards to monitor your environment in real time through log data. Once you identify an anomaly that requires your attention, you can start troubleshooting by delving further into the issue using the Open with option and the intent mechanism in the new Logs app. This app provides advanced analytics, such as highlighting related surrounding traces and pinpointing the root cause, as illustrated in the example below.

Leveraging the capabilities of Grail and Smartscape® topology, Dynatrace seamlessly integrates logs, metrics, and traces to offer enhanced context for troubleshooting and in-depth analysis. This integration facilitates a comprehensive understanding of individual transactions through the Distributed Traces app and aids in pinpointing the root cause of issues when using the Problems app.

Intuitive data access with Davis CoPilot AI assistant

There’s also a brand new and completely different option for analyzing data using natural language; using the power of generative AI, Davis CoPilot™ converts your conversational prompts into accurate DQL commands, allowing both non-technical users as well as experienced data analysts to make data-driven decisions faster than ever before.

To learn more about how Davis CoPilot empowers you and your teams, see our blog post, Announcing General Availability of Davis CoPilot: Your new AI assistant.

Search metrics from anywhere

A speedy way to begin your data exploration journey, particularly if you already know which data you need, is to utilize our global search feature to effortlessly find and explore metrics from anywhere on the Dynatrace platform. This feature lets you explore any available metric and add it to Notebooks or Dashboards.

Imagine a colleague mentioning a newly released metric for Kubernetes during a coffee break. Rather than manually exploring the Kubernetes app you can simply open the Dynatrace global search and enter “Kubernetes network.” The relevant metrics are then immediately displayed alongside further details.

This efficient method allows you to easily browse and identify the appropriate metrics; adding them to your notebooks and dashboards requires just a single click.

Get started discovering and exploring your data

It has never been easier to analyze data within Dynatrace. Kickstart your data exploration journey and familiarize yourself with ready-made dashboards and the new Explore data interface. By the way, we also added new data visualization capabilities by adding new chart types and chart interactions.

Curious about our latest releases and upcoming features for Dashboards and Notebooks? Check out our community roadmap thread to stay updated!

The post Transform data into insights with Dynatrace Dashboards and Notebooks appeared first on Dynatrace news.

Today, IT and development teams have myriad responsibilities in managing and working with cloud environments. They need to create new products and maintain existing ones to deliver customer value at speed and scale while managing risk. Therefore, modern observability platforms are becoming a must-have tool for these teams.

Teams can now use an observability platform to unify operations, business, and development data to gain automatic, precise answers about cloud environments and user experience. Further, developers can build more agility into their processes with an intuitive, low-code approach to create custom, compliant, and intelligent data-driven apps and automation.

The ability to create custom apps becomes increasingly important as organizations strive to innovate and grow. They want to develop secure, compliant custom apps and integrations—whether in the cloud or on premises. Indeed, according to one report, more than 50% of U.S. organizations have over 100 custom applications in development and testing today.

A modern observability platform like Dynatrace is uniquely positioned to serve as a foundation that enables teams to build low-code, custom apps that are secure, compliant, and based on precise answers. And with Dynatrace AppEngine, IT pros have the tools to build custom apps that serve their organization’s business needs and fit in their multicloud ecosystems.

The convergence of observability and security data

Organizations now realize that better understanding their applications and cloud environments is the key to assessing their health from both performance and security perspectives. Therefore, leaders are embracing a converged security and observability approach by unifying all observability and security data in a single location or source of truth.

As a result, these leaders can ask different questions of the same data. And because the data is complete and in context, the answers and insights are always accurate, resulting in an increased trust of these data-backed insights. As development and security teams work more closely together, they also recognize the importance of converging observability and security data to deliver answers and insights through secure, compliant, enterprise-grade applications.

Dynatrace AppEngine supports these goals and empowers customers and partners with an easy way to create and share custom apps for their IT, development, security, and business teams. With consistent answers and insights, organizations can solve their toughest business challenges.

Unifying data, retaining full data context

The Dynatrace platform now uniquely consolidates observability, security, and business data while retaining full context and dependency mapping with its data lakehouse, Grail. Additionally, its modern architecture delivers cost-effective storage and compute. As a result, teams benefit from low-cost cloud storage that provides access to all data and doesn’t require data rehydration. This frees teams from manual approaches to connecting siloed data—using imprecise machine-learning and correlation-only techniques—and the high total costs of using multiple DIY-style solutions.

AppEngine uses this data and simplifies intelligent app creation and integrations for teams throughout an organization. It provides automatic scalability, runtime application security, secure connections and integrations across hybrid and multicloud ecosystems, and full lifecycle support, including security and quality certifications. As a result, for the first time, any team in an organization can create intelligent apps powered by causal AI and build integrations for use cases and technologies specific to their unique business requirements and technology stacks.

Delivering precise answers and insights to the whole enterprise with secure apps

AppEngine is a core technology in the Dynatrace platform that enables anyone in IT, business, or security to create and share inherently secure, custom apps that leverage causal AI and data and scale well. It’s a more productive and secure approach for teams to meet requirements without undermining an organization’s security posture. By using these secure apps, teams are empowered with powerful mechanisms for collaboration and insight-sharing across domains.

AppEngine is built for enterprise software development needs

The custom applications that teams develop run in the Dynatrace environment and automatically meet enterprise requirements, such as scalability, availability, performance, scale, governance, and full lifecycle support.

AppEngine provides a runtime environment that automatically scales the environment, ensuring the application is highly available and performing healthily. Additionally, AppEngine handles security and compliance by leveraging the capabilities of the Dynatrace platform, including access control, secrets management, audit logs, and app signing. Further, the EdgeConnect capability allows secure connections to on-premises systems. This ensures users do not damage the enterprise’s security posture with insecure rogue applications. And, lastly, it provides full lifecycle support with a rich developer experience to create, deploy, and manage applications easily.

Endless possibilities with custom apps powered by observability, security, and business data

Dynatrace customers and partners can now easily bring their business logic to data and create applications on the Dynatrace platform. Dynatrace tames the underlying complexity of managing data in a cost-efficient, performant way, ensuring the integrations with an organization’s ecosystem solutions are inherently secure and everything runs and scales in an automated way. This allows teams to focus on quickly creating apps and sharing with others to promote collaboration and data-backed decision-making.

The following apps showcase the power of AppEngine and the diversity of use cases it can address:

• Smartscape Health View. Teams can visualize an application’s vital signs, including its security posture. This app also showcases AppEngine’s ability to unlock actionable insights from data through enrichment, visualization, and analytics.
• Site Reliability Guardian. This enables teams to proactively maintain service-level objectives by automating quality and security gates. This also exemplifies how apps created using AppEngine fuel answer-driven automation to optimize cloud operations.
• Carbon Impact. Organizations can understand and reduce the carbon footprint of hybrid and multicloud ecosystems. This also demonstrates how AppEngine can help teams measure and optimize the key performance indicators that matter most for business executives or regulatory requirements.

This newfound agility in packaging and delivering data-driven answers and insights in a secure, compliant way is highly beneficial for customers seeking to use data for automating insights and actions.

Taking your data insights to the next level

At Perform 2023 in Las Vegas, Dynatrace announced a host of platform enhancements to enable IT pros to move from data in context to insights on which they can execute with confidence. The platform has been updated with a variety of capabilities to enable teams to discover data insights more easily:

• expanded Grail data lakehouse to support new data types, such as metrics and distributed traces, and enable exploratory analytics with causation powered by topology and dependency mapping;
• a new user experience for collaborative and exploratory data analytics using Notebooks;
• Dynatrace AutomationEngine for automating BizDevSecOps workflows driven by answers from causal AI; and
• Dynatrace AppEngine with a low-code tool set and application programming interfaces for building and sharing custom, compliant, data-driven apps.

To learn more about Dynatrace AppEngine and how to create low-code applications for exploratory analytics, check out our on-demand Perform sessions.

The post AppEngine empowers organizations to create custom apps for better data insights appeared first on Dynatrace news.

Grail – the foundation of exploratory analytics

Grail can already store and process log and business events. Now we’re adding Smartscape to DQL and two new data sources to Grail: Metrics on Grail and Traces on Grail.

Introducing Metrics on Grail

Despite their many advantages, modern cloud-native architectures can result in scalability and fragmentation challenges. Ensuring observability across these environments requires access to data at a massive scale. The proliferation of metrics can quickly result in a high cardinality challenge, with each service, host, or Kubernetes pod adding its own unique values to the data set.

Grail solves this scalability issue! Metrics on Grail is architected to manage billions of metrics to cope with cardinalities and unique value combinations of 1 trillion potential permutations for timeframes beyond a year. This is only possible because of our no-index approach and massive parallel processing capabilities, which enable Dynatrace to offer extra-long data retention (15+ months) at full granularity that is cost-efficient and fast.

You no longer need to split, distribute, or pre-aggregate your data. Let Grail do the work, and benefit from instant visualization, precise analytics in context, and spot-on predictive analytics.

Introducing Traces on Grail

A distributed trace follows a transaction on its journey through every service, cloud platform, and host in your environment. Having access to traces that span the full hybrid and multicloud stack enables developers to debug their applications in production and understand dependencies in live environments. For more complex cloud-native architectures, adding more services and applications leads to a massive increase in the volume of collected traces.

With Grail, we address these customer challenges by offering the most powerful and future-proof trace analytics solution on the market, which:

• Handles data volumes of hundreds of terabytes a day
• Retains large data volumes for up to 15 months in a highly cost-efficient way
• Ensures that data retains its context by assembling trace spans into PurePath® distributed traces (including additional code and thread profiling data)
• Returns instant query results in real-time using indexless queries

Smartscape for DQL: Context is king

Bill Gates wrote an essay in 1996 entitled “Content is King” in which he described the future of the internet as a marketplace for content. In DevSecOps, content includes applications and services—in addition to information about the environments where they run and the users who use them. Observability and application security use cases rely on data. However, data on its own, without context, doesn’t reveal all its insights. Whereas Bill Gates’ observation is still valid, for the DevSecOps industry today, a more accurate description is “context is king.”

In a traditional monitoring environment, metrics are aggregated data points that lose their context and granularity when data sets are trimmed to make them more manageable. With Dynatrace and Smartscape for DQL, metrics are a completely different game. Whether it’s metrics, logs, events, traces, or any other data type, Dynatrace not only retains the data context but also enables you to analyze data in its semantic context without boundaries.

These capabilities are powered by Smartscape for DQL, a directional graph representing the real-time topology and dependencies of a data architecture. Smartscape unifies the different data types ingested into Dynatrace and retains the full context of this data to enable holistic and precise data analytics.

With the Dynatrace Query Language (DQL), teams can perform these analyses by asking questions that weren’t possible in the past. There are now boundless possibilities, such as identifying users affected by a service outage in a red-alert scenario or doing forensic research on a recent data breach. With DQL, you can easily combine different data types into a single query.

The power of Smartscape is, of course, not limited to manual queries. The same data model fuels Davis, the causational AI engine at the core of the Dynatrace platform. Dynatrace has used Davis for many years and is leveraging its power for root cause analysis, identifying security risks, and many other use cases. Davis doesn’t rely on machine learning or statistical correlations—the models that power most available AIs and try to correlate data points by timestamp analysis, searching for similarities, or processing manual instrumentations. Alternatively, Davis is causal AI that reflects continuously updated topology and dependencies (powered by Dynatrace Smartscape) and understands the precise relationships and dependencies between isolated signals.

Whereas other AIs must guess, Davis knows and eliminates false positives. With the addition of Dynatrace Grail, which ingests, retains, and maintains data in context, we’re revolutionizing the observability industry and extending Dynatrace further to provide answer-driven analytics and automation for unlimited observability and security use cases.

Exploratory analytics – empowering people and data

While data is considered by some to be the new gold, it’s people that still make the difference. Gaining insights from data stored within Dynatrace has traditionally been limited to people within an organization who have specific expertise and training. This is no longer the case.

With the new Dynatrace user experience, we’re introducing new concepts and changing how people across organizations work and interact with data.

New user experience

How many user interfaces have you used that are defined by the data and data types they show rather than the use cases they support? How often have you spent time decluttering or trying to make sense of the information presented on a dashboard? How often have you wished you could interact with data in the same intuitive way you interact with information on your smartphone, quickly switching between visualizations, easily understanding the context behind a spike in a chart or diagram, or digging deeper to perform ad-hoc analysis?

When we started working on Strato—the new Dynatrace design language that powers our new user experience—we developed a few core principles to address the design challenges stated above:

• Designing software for DevSecOps use cases means handling data—large volumes of data that need to be accessible for in-depth analysis in an easy-to-digest interface. We therefore completely rethought the user experience: the interface is user-centric rather than data-centric. We designed Dynatrace in a way that places the user in the middle, offering a flexible UI—tailored to individual needs and deriving rich insights from different perspectives.
• The interface is simple—whether you’re a first-time user, an occasional user, or an SRE using Dynatrace as your single source of truth, the experience is simple and easy to learn.
• The interface offers infinite possibilities. Users need to be able to work efficiently regardless of how large their environments are. Sharing and collaborating with teams is now easier than ever before.

These principles all align with a single, overarching goal: making data and insights derived from analytics available to a wider audience. To achieve this, we designed the new Dynatrace user experience (UX) to facilitate collaboration with teams across organizations—IT, development, security, and business—and solve everyday problems. We focused on democratizing the user interface, making it less trivial and more accessible, and empowering teams to better understand data signals and make data-backed decisions.

User in context

We already mentioned above that putting data in context is vital for Dynatrace. This is also true from a user experience perspective. With Strato, we add user context to the Dynatrace UI.

Charts are now interactive—data points are clickable. Think of a chart that shows a spike in response time because of a deployment two hours earlier—any user can now hover over this data point and begin interacting with the underlying data, whether it’s a drill-down or just the context of the spike.

Introducing Every component and view in the Dynatrace web UI is interlinked based on user context or “intents”. Similar to what you know from your smartphone when sharing an image on your favorite social media channel, when opening a page within Dynatrace, you can easily pass and share the context of your analyses to any other app on the Dynatrace platform. The selection of available apps that are presented is completely context-sensitive and can even be expanded based on your needs.

Simplifying data analytics with Dashboards and Notebooks

In addition to new concepts revolutionizing the overall Dynatrace user experience, we’re introducing two new apps to the Dynatrace platform: Dynatrace® Dashboards, a complete overhaul of the dashboarding experience, and Dynatrace® Notebooks, for on-demand data exploration. These apps make it easier for more team members to explore, visualize, and collaborate on analytics projects. The following principles guided the development of these new capabilities:

• Offer drastically faster and simpler flows, guided by Strato, the new Dynatrace design system
• Fetch all Dynatrace data from one place and even combine it in a single query with Grail
• Integrate external data easily with Dynatrace functions
• Add flexibility and versatile filtering with variables
• Take context with you as you seamlessly navigate the Dynatrace UI using intents

Dashboards and Notebooks have individual strengths that make them the best choice for solving specific use cases.

Observe data with Dynatrace Dashboards

Dynatrace® Dashboards transforms complex data into easy-to-understand visualizations. Dashboards is your go-to app for quick and clear data overviews, whether you need a status-quo view that can be observed over time or you need to share aggregated views with management or business teams.

Dashboards offers an interactive experience with full support for all capabilities and datatypes offered by Grail, allowing you to query not only metrics, but also logs, events, and even external data. It serves as your starting point for further deep-dive analysis, offering more detailed drill-downs via Notebooks (see below).

The all-new Dashboards app is your answer to live data visualization and observation. From data to insights in seconds, and we’re just at the beginning.

Explore data with Dynatrace Notebooks

Dynatrace Notebooks is your on-demand window into data exploration. It addresses the challenge of finding the right data, cleaning, filtering and transforming the data and finally connecting with other data to understand underlying dependencies. You no longer need the help of a data scientist for such tasks—Notebooks enables every Dynatrace user to perform any type of analysis on data stored in Dynatrace.

Start creating data-driven documents and perform custom analytics. Depending on your use case, Notebooks can persist a status quo and create a snapshot whenever necessary or be “self-updating” using current data to always reflect the actual status. You can easily interact with any query result by “slicing and dicing” the data stored in Grail: advanced filters, refinements, aggregations, and sort orders, are just a click away. It’s even possible to harness the power of Davis by adding predictive forecasts to identify future trends with a simple click.

Suppose you need the limitless power of Grail. In that case, you can easily create and edit DQL queries to filter, join, and transform data any way you need it, or even extend Notebooks with custom logic and external data by adding ad-hoc functions powered by Dynatrace® AppEngine.

Whether you’re analyzing new opportunities, the latest vulnerability post-mortem, or your executive production report, Notebooks does it all and ensures that both your query and results are persisted and ready to be shared with your team members. Empowered by Grail, Notebooks is the Swiss Army knife of the Dynatrace platform—built for collaborative data exploration and analysis.

Summary

With these newly added capabilities, Dynatrace users can now perform any custom query, leveraging Dynatrace Grail AI-fueled graph analytics power. This delivers instant and precise answers for an unlimited array of use cases:

• Business impact: quickly identify impacted users by mapping observability and security findings to your business context and improve customer satisfaction by querying for e-commerce customers who are unable to finalize their check-outs due to a service outage.
• Automation: understand the potential impact of remediation actions on dependent components.
• Security: protect customers and brands by conducting application security forensics to identify, mitigate, and prevent data breaches.
• Business process health: show and analyze the health status of complex processes even if dependencies are non-transactional.
• Optimize: enable more efficient multicloud operations by predicting cloud performance and utilization over time to optimize resource allocation based on user needs.

The Dynatrace analytics platform converges security and observability data, enabling cost-effective end-to-end analytics at a large scale with long retention times, in context with your business, thus multiplying your value from data: every imaginable analysis of data in Dynatrace is now possible!

What’s next?

The new Dynatrace user experience, including the newly designed Dashboards, Notebooks, and Dynatrace Grail support for metrics and Dynatrace® Smartscape for DQL, will be available in Q2 2023. Grail support for Dynatrace PurePath® distributed traces will be open for preview in Q2 2023.

In the meantime, watch out for upcoming Observability Clinics and “Ask me anything” sessions covering the main topics of this blog post. You can either view a list of the next webinars on our website or follow us on LinkedIn to stay up to date with upcoming announcements and activities.

The post Expanded Grail data lakehouse and new Dynatrace user experience unlock boundless analytics appeared first on Dynatrace news.