Your on-call engineer is looking at intermittent HTTP 500s from a service running on a virtual machine that was perfectly healthy twelve hours ago. Nothing changed in the application. No recent deployments. Logs show connection timeouts — but only under load, and only to external services. The app itself looks fine.

This is the signature of SNAT port exhaustion: Azure’s most reliably invisible production failure. It masquerades as an application bug while the root cause sits quietly in your networking configuration. Left unresolved, it degrades under load, confuses your developers, and burns investigation hours on symptoms instead of causes.

With the general availability of Azure Cloud Platform Monitoring, Dynatrace now ships a pre-built alert that catches this exact failure — before your engineers are paged, or the moment they are. This is the story of how that plays out.

What is SNAT exhaustion?

Source Network Address Translation (SNAT) is how Azure allows resources in a virtual network to make outbound connections to the internet without exposing a public IP on each instance. When a backend instance behind an Azure Load Balancer initiates an outbound TCP connection, the load balancer performs SNAT: It maps the source IP and port to one of its frontend IPs and a port from a shared pool.

The trap: Azure allocates a limited number of SNAT ports per backend instance. The exact number depends on how many instances are in the backend pool — smaller pools get more ports per instance (up to 1,024), while larger pools get fewer (as low as 32 per instance). Each active outbound connection consumes one port for the duration of the connection plus its TIME_WAIT period — typically up to four minutes. Under normal load, this is plenty. Under burst traffic — or when an application makes many short-lived outbound calls without connection pooling — those ports vanish fast.

When the pool is exhausted, new outbound connections fail with a generic network error. The application logs a 500 or a timeout. Developers stare at their code. The infrastructure looks healthy in Azure Monitor… unless you know exactly which metric to watch and where.

12:03 PM — The alert fires

At 12:03 PM, Dynatrace fires a problem notification: “Azure Load Balancer SNAT Port Exhaustion High” — one of the pre-shipped health alerts that comes with Azure Cloud Platform Monitoring.

The alert details show the affected resource: retail-snat-lb, a production Load Balancer in the prod-eastus subscription, with SNAT connection counts climbing rapidly toward the allocated port ceiling. The problem card surfaces the backend IP addresses approaching exhaustion — in this case, two instances already above 75% of their allocated ports — alongside the duration, the severity trend, and a direct link into the Clouds app to investigate.

What’s going on?

Opening retail-snat-lb in the Clouds app, the metrics make the problem immediately clear. UsedSnatPorts is peaking at 256 — against an allocated ceiling of 128 ports per backend instance. That is 100% utilization, and it is not a one-off spike. The pattern repeats with every traffic wave hitting the backend.

Metrics tell the story, but logs confirm it. With Azure resource (diagnostic) logs ingested into Dynatrace, we can corroborate what the SNAT metrics are showing.

The last 10 error and warning log entries confirm it: the Azure Load Balancer is experiencing SnatPortExhaustion.

Azure Cloud Platform Monitoring continuously maps your cloud topology and persists it in Smartscape^® as nodes. Dynatrace discovers relationships between Azure resources and creates Smartscape edges for the relevant nodes.

From the related resources tab, we can drill into the outbound rule configuration for this Load Balancer.

We can see that allocatedOutboundPorts is currently set to 128. This is the custom number of SNAT ports which are pre-allocated per backend instance for outbound connections. If a VM uses all its allocated ports — due to many concurrent or short-lived outbound connections — new connections fail with SNAT exhaustion errors.

Increasing allocatedOutboundPorts reduces this risk, but there is a tradeoff: More ports per instance means fewer instances per frontend IP. With a single frontend IP (64K ports), setting 1,000 ports per instance supports roughly 64 instances; setting 128 ports per instance supports roughly 500 instances.

But what backend instances are serving traffic? We can query Smartscape topology using DQL to understand exactly which Azure Network Interfaces are associated with the Load Balancer’s backend pool.

We can see there are two Azure Virtual Machines whose network interfaces are registered in the backend pool, both making outbound calls through a single Azure Load Balancer.

This matters because SNAT exhaustion is a per-instance problem. With two VMs in the backend pool, Azure pre-allocates 128 SNAT ports to each instance via the outbound rule. Under load, both VMs are independently hitting their own port ceilings — which is exactly what the metrics are showing. The topology makes this architecture immediately visible, without navigating Azure Portal resource groups or drawing a diagram by hand.

Observability superpowers

With the root cause identified on a single Load Balancer, the next question is obvious: Is this the only one at risk?

This is where Dynatrace Assist comes in — and with Azure-specific agentic skills arriving in an upcoming Dynatrace release, it gets even more powerful. Assist is your natural language gateway into Dynatrace Intelligence — the agentic operations system that brings the full platform together. Instead of switching between dashboards, writing queries by hand, or clicking through Azure Portal subscription by subscription, you ask a question in a conversational interface. Assist draws context from Grail™ and maps relationships through Smartscape to deliver grounded, data-backed answers.

Once these skills are generally available, asking Assist to “list all Azure Load Balancer outbound rules sorted by allocatedOutboundPorts” will generate a DQL query that scans configurations across every connected Azure subscription in seconds — the kind of cross-subscription audit that would take hours of portal hopping. The result instantly surfaces every Load Balancer with details of their SNAT configuration, turning a single resource investigation into an environment-wide remediation sweep.

Additionally, you’ll be able to quickly understand which Azure resources are affected for a load balancer that has this custom SNAT configuration applied by asking, “For load balancer retail-snat-lb which backend instances are affected by this configuration?”

“Our Madrid MultiCloud strategy is based on a unified observability office powered by the Dynatrace platform, which allows us to anticipate problems, increase agility, and scale our services. This approach is key to driving the City Council’s digital transformation and delivering better services to citizens. Specifically, Dynatrace Cloud Operations for Azure helps us detect early warning signs, reduce operational noise, and respond automatically when incidents occur, allowing our development teams to focus on the continuous delivery of new features.”

– Mónica Romero Domínguez, Head of Observability and Monitoring, IT Agency at Madrid City Council

Two options, one outcome

Fixing SNAT exhaustion on an Azure Load Balancer is straightforward once you know what you are dealing with.

Option A: Attach a NAT Gateway. A single NAT Gateway with one public IP address provides 64,512 SNAT ports. With multiple IP addresses, you multiply that ceiling further. NAT Gateway completely decouples outbound connectivity from the Load Balancer’s frontend IP allocation and is the recommended pattern for workloads with significant outbound traffic.

Option B: Define explicit outbound rules. If NAT Gateway is not feasible, add explicit outbound rules to the Load Balancer and associate multiple frontend IP addresses. Azure allocates ports proportionally — more frontend IPs means more ports per backend instance.

Either approach will cause the SNAT connection utilization to drop back to baseline. The recovery is visible immediately in the Dynatrace dashboard, and the pre-shipped health alert resolves automatically once utilization falls below the critical threshold.

Azure observability at scale

The investigation above was possible because retail-prod-eastus was already being monitored — not because someone remembered to configure it. Onboarding happens once at the Azure Management Group level, and Dynatrace automatically discovers every subscription beneath it, including subscriptions created after the initial connection. Authentication uses federated credentials: there are no shared secrets to store, rotate, or let expire.

Everything seen during this investigation — the pre-shipped alert, the SNAT metric, the topology, the VM logs — arrived without any Dynatrace components running inside Azure. Metrics, topology, logs, and events are polled directly by the Dynatrace platform. This replaces the previous approach, which required self-hosting the Dynatrace Azure Log Forwarder for log ingestion — a component that needed to be deployed, scaled, and maintained inside each Azure environment.

The SNAT metric that surfaced this problem was available out of the box, part of the Dynatrace curated metric collection set for Azure Load Balancers. Coverage is not limited to what Dynatrace has pre-selected: Auto-discovery can ingest all metrics available for any Azure service, or any Azure Monitor native platform metric can be collected on demand — without waiting for Dynatrace to add explicit support. The resource inventory underlying the Smartscape topology is built from Azure Resource Graph, scanning subscriptions continuously so the entity map reflects the environment as it actually is.

Every ingested signal — metric, log entry, event — is automatically linked to the Smartscape entity representing the Azure resource that produced it. The reason the SNAT spike, the VM timeouts, and the Load Balancer topology appeared together in the same investigation is that they are stored in the same context. There is no join to write, no dashboard to cross-reference. The data arrives pre-correlated.

Smartscape^®, Grail™, and the Dynatrace logo are trademarks of the Dynatrace, Inc. group of companies. All other trademarks are the property of their respective owners.

The post The silent network killer: Preventing Azure SNAT exhaustion with Dynatrace appeared first on Dynatrace news.

The April 2026 Dynatrace SaaS releases bring six updates aimed at a familiar problem: too much manual work between a signal and an answer. The updates focus on native cloud visibility, deeper Kubernetes insights, consistent severity handling, faster investigations, and smoother analytics work.

Explore all updates hands-on in the Release Radar launchpad.

A native Azure experience in Clouds

What does Dynatrace add for Azure practitioners?

Dynatrace now extends the enhanced Clouds experience to Microsoft Azure, putting Azure subscriptions on the same footing as AWS. Metrics, logs, metadata, and topology now sit in one managed view, so Azure teams can move from inventory to investigation without stitching the picture together by hand.

What you get out of the box

• Opinionated insights and ready-made dashboards built from enriched Azure telemetry, so investigations start with answers instead of a blank canvas.
• Pre-configured health alerts for Azure, created and managed directly in Clouds, with drill-down, search, and filtering directly in the Clouds app.
• Broad metric coverage for any Azure Monitor native platform metric across Azure services.
• A rich Azure topology inventory that periodically scans Azure environments and enriches resources with native metadata such as tags and subscription IDs, all queryable with Dynatrace Query Language (DQL).
• Simple onboarding and lifecycle management that turns Azure subscriptions into native Dynatrace connections and manages them centrally.

Dynatrace also adds drilldowns from cloud entities into the relevant Dynatrace experiences, so teams can keep moving instead of bouncing between cloud and platform views.

Kubernetes visibility for autoscaling and custom resources

What’s new in Kubernetes observability?

Dynatrace extends Kubernetes visibility to two additional object types that SREs and platform teams rely on daily: Horizontal Pod Autoscalers (HPA) and Custom Resources (CRs).

Horizontal Pod Autoscaler as a first-class object

HPA is now a first-class object in enhanced Kubernetes visibility. You can see when scaling kicked in, what triggered it, and how desired and actual replica counts lined up next to the workloads involved.

Custom Resource insights

You can monitor up to five Custom Resources per cluster, surfaced the same way as built-in Kubernetes objects. This brings CRD-heavy ecosystems such as Argo, Istio, Cert-Manager, Kyverno, and operator-managed databases into the same investigation scope as the rest of your cluster.

For clusters connected through cloud integrations, the Kubernetes cluster details page now exposes the underlying cloud configuration (EKS, AKS, or GKE) in YAML or JSON, making cloud-side and cluster-side state accessible in one place.

A unified severity model for alerts and problems

What is event.severity in Dynatrace?

Dynatrace introduces a standardized event.severity field for alerts and problems, aligned with the ITIL Incident Management framework. Severity is stored in Grail as an integer from 1 (Critical) to 5 (Informational) and is shown as a human-readable label across the platform.

Severity levels at a glance

Severity automatically propagates from correlated alerts to the parent problem, with the highest severity always taking precedence. This gives teams one severity model to filter on, route with, and escalate from.

You can now:

• Filter the problem feed by severity
• Display a severity column with visual icons in problem lists
• Use severity as a condition in Workflows for alert routing and notifications

Faster Investigations with Smartscape navigation

What changed in Smartscape?

Smartscape now offers all six ready-made views, such as vertical topology, horizontal topology, and visual resolution path, just a click away in a persistent side panel. You no longer need to return to the landing page in the middle of an investigation.

The new Recent views section shows your latest investigations, making it easy to reopen them, compare them, and keep working as you test a root-cause hypothesis.

The result is less backtracking in the middle of an incident.

Dashboards and notebooks: productivity improvements

What’s new for dashboard authors and analysts?

The latest release adds several practical upgrades for team members who build dashboards and work in notebooks every day.

• Treemap visualization for identifying dominant categories in hierarchical data, such as requests per service by Kubernetes namespace.

  

• Dashboard variables for dynamic coloring and thresholds, so visual conditions stay in sync with environment or team selectors.

  

• Centralized tile indicator controls, allowing you to show or hide warnings, descriptions, and custom timeframes at the dashboard level.

  

• Direct image upload in Markdown using a built-in image library shared across Dashboards, Notebooks, and the Launcher.

  

• Row marker coloring for tables, making it easier to visually group related rows without sacrificing readability.

  

User experience improvements

Why does the platform feel faster?

This release smooths out the path from the first symptom to root cause analysis. Tracing and services workflows now handle high-span traces more reliably, show timing more clearly, and surface useful sample traces earlier.

Table-first workflows also benefit from richer entity-detail tables, better filtering, and clearer structure, helping teams answer more questions without switching views. Navigation patterns, overlays, and error messaging are now more consistent across the platform, reducing mental overhead when time is tight.

Why these updates matter

Taken together, these updates eliminate inefficiencies in the work that teams do every day. Cloud operations teams, Kubernetes SREs, on-call engineers, and analytics authors get richer context, faster paths to answers, and simpler ways to share what they find. This is where Dynatrace earns its keep under pressure.

Explore the updates live in the Release Radar launchpad.

The post Dynatrace Release Radar 04.26 appeared first on Dynatrace news.

Enterprise cloud has outpaced traditional reactive monitoring. As workloads multiply across AWS, Azure, and Google Cloud—and extend into data centers—teams find themselves contending with vast amounts of telemetry, ephemeral infrastructures, and constant change. Visibility is tough; clarity of impact, ownership, and root cause is tougher.

Today’s tech stacks are distributed by design, featuring containers, serverless architectures, managed services, and data planes that can spin up and down in seconds. High-cardinality signals, fragmented logs, and partial traces create blind spots across accounts, subscriptions, and projects. In hybrid setups, network overlays, identity boundaries, and platform services blur the lines between where issues begin and how they propagate.

Organizationally, the challenge is even bigger. Platform, SRE, Dev, SecOps, and FinOps each hold a piece of the truth. However, inconsistent tagging and governance, manual runbooks, and handoffs across time zones can slow MTTR, fuel tool sprawl, and inflate budgets. The goal is to provide clear risk and cost insights, reduce noise, and deliver faster, context-rich answers.

However, visibility alone isn’t enough to achieve this goal. AI-driven context, such as topology-aware analytics, causal correlation, and safe automation, shifts operations from reactive firefighting to proactive prevention that’s aligned with SLOs, compliance, and budgets.

Today, we’re introducing Dynatrace enhanced cloud operations for AWS, Azure, and Google Cloud, delivering complete visibility across all your cloud and hybrid environments with deeper, actionable insights. If you’re ready to take the guesswork out of monitoring your cloud environments, read on to see how Dynatrace helps you collaborate faster, resolve issues earlier, and run at enterprise scale with confidence.

What is Dynatrace Cloud Platform Operations?

Dynatrace Cloud Platform Operations takes the guesswork out of monitoring by redefining how organizations manage complex cloud environments. By unifying all cloud signals—metrics, logs, and events—into a single AI-powered platform, Dynatrace delivers complete visibility and actionable insights at scale.

Every data point is enriched with context and analyzed by Dynatrace AI, enabling proactive automation and informed decision-making. This ensures faster troubleshooting, better resource efficiency, and simplified onboarding—all without the need for additional infrastructure components.

Organizations eliminate blind spots and accelerate resolution by gaining real-time visibility into the health, performance, and configuration of their cloud resources. This allows them to maintain the correct governance through tag-based control, ownership, and cost allocation, thereby aligning teams while reducing operational noise.

Additionally, the latest advancements in cloud observability provide real-time visibility into resource health, performance, and configurations, allowing teams to act quickly and decisively while reducing the time to resolution.

Start monitoring your cloud environment

Spin up monitoring without spinning up your infrastructure. The new cloud connections are fully managed by Dynatrace and guided by a simple wizard. It gets you from setup to actionable telemetry in minutes; no agents to wrangle, no custom pipelines to maintain.

Once connected, you gain instant visibility across all your cloud environments. Connect your AWS, Azure, or GCP accounts once, and Dynatrace auto‑ingests everything from compute and databases to storage, networking, and security configurations. Platform coverage has been expanded to capture more data types than ever, including metrics for any supported cloud service and a richer set of cloud events, such as hyperscaler‑native security alerts.

The new cloud connections are:

• Secure by design: native authentication offers least‑privilege access and auditable permissions.
• Practitioner‑friendly: a step‑by‑step wizard with built‑in checks and defaults works across accounts and regions.
• Zero overhead: the Dynatrace platform manages the connection end‑to‑end, so you focus on insights, not maintenance.

With all your cloud data unified, Dynatrace automatically applies the tags you already use in your cloud environments, bringing your existing operational model directly into the platform. Your existing cloud tags instantly drive access control, ownership, cost allocation, alert routing, and preventive workflows, with no manual tagging or re‑mapping required. Additionally, tag‑enriched signals keep operations aligned by allowing you to filter everything by owner, app, or environment for precise alert routing and actionable insights. This paves the way for more advanced analytics and clear insight into what’s happening across every environment.

The enhanced cloud ingest not only unifies telemetry and context; it also captures all configuration details (VPCs, load balancers, security groups, subnets, network services, compute metadata, and more). The new Smartscape® uses this information, along with cloud monitoring data, to provide a comprehensive, always-accurate topology of your cloud infrastructure. You can use the new Smartscape app to navigate your cloud topology, visualize dependencies, and eliminate hidden or forgotten resources. Ready-made views for AWS and Azure provide a comprehensive, automatically discovered cloud inventory across services, databases, networking layers, and security controls.

Additionally, you get ready-made dashboards, essential metrics, and expanded cross-cloud visibility, providing you with immediate clarity, especially when issues originate on the provider side, thanks to built-in AWS Health event integration.

All of this comes together in our newly enhanced Clouds app, a shared place for teams to analyze services, metrics, events, and logs. Pre-built dashboards and alerts automatically highlight unhealthy resources, helping teams stay ahead of issues, while the streamlined onboarding process eliminates the need for additional collectors or components. It’s fast, safe, and modern—exactly how cloud onboarding should feel. Ready to see it in action? Keep reading to see the magic.

Transform from reactive monitoring to proactive cloud operations

Dynatrace transformed cloud monitoring into proactive cloud operations by combining AI-powered observability with intelligent automation. This allows organizations to move beyond simply identifying problems to actively solving and preventing problems.

With Dynatrace, you can remediate issues before they impact your users, prevent future issues, and optimize your cloud environments to ensure they operate at maximum efficiency and resiliency.

Prevention

Leave reactive firefighting behind and gain the foresight needed to stay ahead of issues. Dynatrace’s AI-driven automation delivers proactive insights that allow you to identify and resolve potential problems before they impact your users. By predicting anomalies and triggering automated workflows, Dynatrace helps maintain high availability and optimal performance across your cloud environments. This proactive approach minimizes downtime, protects user experience, and ensures your teams can focus on strategic initiatives rather than crisis management.

Remediation

Instead of wasting valuable time on lengthy resolution cycles that disrupt business operations, accelerate recovery with intelligent automation. Dynatrace automates root cause analysis and remediation, enabling self-healing workflows that dramatically reduce resolution times. By eliminating manual troubleshooting and streamlining incident response, your teams can focus on driving innovation rather than firefighting. With AI-driven insights and automated corrective actions, Dynatrace ensures issues are resolved quickly and efficiently, thus minimizing impact, improving reliability, and keeping your business moving forward.

Optimization

Stop overspending on infrastructure due to a lack of visibility into resource usage and performance. With Dynatrace, you can continuously optimize both cost and efficiency across your environment. Real-time insights into resource consumption and application performance allow you to identify waste and prevent unnecessary expenses. By leveraging AI-driven analytics and automated recommendations, you can improve cost management and drive peak performance in your applications.

Ready to experience the new world of Cloud Operations for yourself?

With the introduction of enhanced cloud operations for AWS, Azure, and GCP, you can achieve smarter collaboration, faster issue resolution, and streamlined operations at scale using the Dynatrace Cloud Platform Operations solution.

AWS enhanced cloud operations

Discover how easy it is to get started using proactive monitoring capabilities for AWS. AWS cloud operations are now generally available for all Dynatrace SaaS customers.

Azure enhanced cloud operations

Interested in seeing the magic for your Azure environments?
Join the Azure Preview program

GCP enhanced cloud operations

Are you a GCP customer looking for a cloud operations solution?
Join the GCP Preview program

The post Redefining cloud operations: Dynatrace brings intelligence to observability 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.

Data pipelines are critical to seamless operations and informed decision making in modern businesses, and efficiently managing and monitoring those pipelines is crucial for maintaining a competitive edge. Without visibility into pipeline performance, teams risk delays, data loss, and costly downtime. As data volumes grow and workflows become more complex, the stakes get higher—making intelligent observability a must-have, not a nice-to-have.

Azure Data Factory (ADF) is a powerful tool for orchestrating and automating data workflows. Whether you’re moving data across hybrid environments, transforming it for analytics, or syncing it between systems, ADF provides the flexibility and scalability needed for modern data operations. Data engineers who deploy Dynatrace with ADF gain valuable insights into performance, business analytics, and automation.

Identifying and resolving pipeline bottlenecks

Keeping data pipelines fast, reliable, and scalable is a huge challenge. When performance dips or failures occur, it’s often a scramble to pinpoint the issue. With Dynatrace, you gain clear visibility into pipeline behavior, resource usage, and failure patterns—making troubleshooting faster and optimization smarter.

Dynatrace addresses key questions such as:

• What are my longest running pipelines?
  Identifying pipelines with extended runtimes helps teams spot inefficiencies in data processing or transformation logic so that you can optimize performance and reduce latency in downstream systems.
• Do I have any failing pipelines?
  Immediate visibility into failures allows teams to respond quickly, minimizing data loss and avoiding disruptions to business-critical workflows.
• Why are my pipelines failing?
  Understanding the root cause—whether it’s a misconfigured activity, resource constraint, or external dependency—enables faster resolution and helps prevent repeat incidents.
• Which pipelines require optimization?
  By highlighting pipelines with high resource consumption or inconsistent performance, Dynatrace helps prioritize tuning efforts for maximum impact.
• Do I need to scale resources or adjust concurrency settings?
  These insights guide infrastructure decisions, ensuring that pipelines run efficiently without overprovisioning or underutilizing resources.

By ingesting logs and metrics from Azure Monitor and correlating diagnostics from Azure Data Factory, Dynatrace delivers actionable insights and a comprehensive view of pipeline performance.

Let’s take a closer look at the dashboard. In addition to status and duration, the captured logs and metrics allow us to thoroughly analyze ADF performance.

• Time spent in queue: Indicates how long the pipeline waits before starting. Prolonged queue times might suggest a need to scale resources, improve scheduling, or adjust concurrency settings.
• Time spent in progress: Reflects the actual execution time of the pipeline. Longer durations here may highlight opportunities to optimize pipeline logic or resource allocation.
• Message: Displays detailed runtime information, including errors. Expanding this field provides additional insights for troubleshooting.

Effective pipeline monitoring transforms reactive troubleshooting into proactive optimization. Leveraging these insights, organizations can not only resolve current bottlenecks but also establish best practices for sustainable, high-performing data environments.

Achieving real-time business insights

Unlocking real-time business analytics isn’t just about tracking technical metrics—it’s about connecting IT operations to business outcomes. With Azure Data Factory (ADF) and Dynatrace, practitioners can enrich pipeline observability by embedding business context directly into logs and metrics. This allows teams to monitor not just how pipelines are running, but what they’re delivering.

For example, imagine a pipeline processing a spreadsheet containing daily revenue figures. By using a Lookup activity in ADF, you can extract key business values—like total revenue or transaction count—and pass them as custom user properties into Dynatrace. This enables dashboards that show not only pipeline health, but also business impact: Was revenue successfully ingested today? Did a failure affect a critical report?

This integration empowers teams to:

• Track business KPIs alongside technical metrics, making it easier to prioritize fixes based on impact.
• Spot anomalies in business data early, such as missing values or unexpected drops in volume.
• Align IT and business teams, fostering collaboration through shared visibility into what matters most.

By bridging the gap between data operations and business insights, Dynatrace helps practitioners move from reactive monitoring to strategic decision-making.

Ensuring pipeline reliability with automation

Harness the power of automation with Dynatrace Workflows, allowing you to streamline processes with Azure Data Factory. With the ADF REST API, you can configure automation to meet your unique business needs.

Consider the case where an administrator needed a way to automatically retry pipelines on failure for those managed by different teams. While native retry policies were available, this simple automation ensured that retries were executed even when the configuration was overlooked.

This is a perfect example of shifting from reactive troubleshooting to proactive reliability. Instead of waiting for failures to be manually addressed, Dynatrace enables automated responses that reduce downtime, improve consistency, and free up teams to focus on higher-value work. By embedding automation into pipeline operations, practitioners can build more resilient systems and ensure that critical workflows stay on track—even when things go wrong.

Get started

By integrating Dynatrace with Azure Data Factory, practitioners gain more than just monitoring: they unlock a smarter, more proactive way to manage data pipelines. From identifying bottlenecks and failures to embedding business context and automating recovery, Dynatrace transforms pipeline operations into a strategic advantage.

The key benefits:

• Faster troubleshooting with deep visibility into pipeline behavior and failure patterns
• Smarter optimization through performance metrics and resource insights
• Real-time business analytics by linking IT operations to business outcomes
• Proactive reliability with automated workflows that reduce downtime and manual effort

The post Transforming Azure Data Factory operations with Dynatrace appeared first on Dynatrace news.

In this blog post, we guide you through configuring a project to visualize real-time CI/CD build and release data for your Azure DevOps pipelines. The resulting visibility enhances collaboration with transparent data, increases productivity by automating monitoring tasks, and enables teams to detect issues proactively. With insights into your Azure DevOps pipelines, you can continuously improve processes, ensuring smoother and more reliable deployments over time.

A notebook version of the blog is also available on the Dynatrace GitHub repository. Download the AzureDevOps - Dynatrace Integration.json file and upload it to your Notebooks app in Dynatrace.

Prerequisites

Before we begin, ensure you have the following:

• Access to your Dynatrace Tenant and permission to create tokens.
• Your tenant ID, which can be found in your environment URL: https://<YOUR_TENANT_ID>.live.dynatrace.com/.
• A token with Ingest Logs v2 scope.
• A token with Write Settings scope.

Create webhooks in Azure DevOps

First, we need to create two service hooks subscriptions in Azure DevOps: one for Builds Completed and one for Release Deployment Completed.

1. Navigate to https://{orgName}/{project_name}/_settings/serviceHooks.
2. During the configuration, do not apply any filters.
3. In the settings page of the subscription, fill in the following fields:
   • URL: https://<YOUR_TENANT_ID>.live.dynatrace.com/api/v2/logs/ingest
   • HTTP Headers: Authorization: Api-token <YOUR_LOG_INGEST_TOKEN>
   • Ensure the text above is copied exactly, replacing only the token.
   • Change “Messages to send” and “Detailed Messages to send” to Text.

Add a new Grail logs bucket

Follow these steps to create a new logs bucket in Dynatrace. Note: This step is optional. You’re welcome to use an existing Grail logs bucket.

1. Open the Storage Management app in your tenant: Select CTRL/CMD + K and enter Storage.
2. Create a new bucket by selecting + in the top right corner.
3. Name the bucket azure_devops_logs.
4. Set the retention time as desired.
5. Set the bucket type to logs.

Configure OpenPipeline with log processing rules

Using OpenPipeline™, you can easily define a rule that routes all relevant log lines you created in the previous step into the bucket. This process also performs the necessary processing steps, such as renaming fields or transforming log data into dedicated events.

1. Open the OpenPipeline app and select Logs in the left pane.
2. Select the Pipelines tab and create a new one by selecting + Pipeline.
3. Name the new pipeline AzureDevOps.
4. Go to Dynamic Routing and create the following new rule:

matchesPhrase(eventType,"ms.vss-release.deployment-completed-event") OR matchesPhrase(eventType,"build.complete")

5. From the Pipeline dropdown, select “AzureDevOps”.
6. Return to your pipelines and open “AzureDevOps”.
7. Under the Storage section, add a new processor > Bucket assignment, set a name and select the azure_devops_logs bucket from the dropdown.

8. Next, open the Processing tab and define a couple of rules.
   1. First, create a new Rename Fields rule and call it “Rename Build Fields” where the left value is the new field name and the right value is the existing field name.

1. resource.buildNumber: buildNumber
2. resource.result: result

1. 2. Second, create another Rename Fields rule called “Rename Release Fields” where the left value is the new field name and the right value is the existing field name.

1. resource.stageName: stageName  
2. resource.project.name: projectName 
3. resource.deployment.release.name: releaseName 
4. releaseStatus:resource.environment.status: releaseStatus

Use the following sample data to verify your rules are working as expected.

Release event sample data:

{ 
       "timestamp": "2024-11-11T15:14:51.104000000-05:00", 
       "loglevel": "NONE", 
       "status": "NONE", 
       "createdDate": "2024-11-11T20:14:50.6300269Z", 
       "detailedMessage.text": "Deployment of release Release-946 on stage Staging succeeded. Time to deploy: 00:14:14.", 
       "dt.auth.origin": "dt0c01.YFMJ6LUO43SFFDW2SF7EW5YZ", 
       "eventType": "ms.vss-release.deployment-completed-event", 
       "id": "1862ab11-c0d4-451a-8b9b-0dfe7f517297", 
       "message.text": "Deployment of release Release-946 on stage Staging succeeded.", 
       "resource.environment.status": "succeeded", 
       "resource.project.name": "devlove-alpha", 
       "resource.stageName": "Staging", 
       "resource.deployment.release.name": "Release-946" 
    }

Create an Azure DevOps dashboard and visualize log data

Now that we have ingested the logs coming from AzureDevOps, let’s visualize the data to get better and quicker insights into our CICD pipelines.

1. Go to the AzureDevOps Git Repository and download the AzureDevOps Dashboard (on Logs).json file.
2. Within Dynatrace, open the Dashboards app and select Upload at the top left corner.
3. Upload the JSON file to start visualizing your Azure DevOps data.

Extract “release” and “build” events

Taking this a step further, we can convert the ingested log data to SDLC (Software Development Lifecycle) events in case we detect a new release or build and discard the related log line afterward.

This helps reduce the number of stored log data and supports further platform engineering use cases, such as calculating DORA metrics, automating development processes, or observing the health of your engineering pipeline.

Disclaimer: The following instructions extract Business events from log data. Once supported by OpenPipeline we propose to extract Software Development Lifecycle Events (SDLC events), which are the preferred way of storing the extracted information.

Note: You may need to request a Log Content Length (MaxContentLength_Bytes) increase depending on how many steps your Release Events have. The integration generates ingest costs for logs and metrics (according to your rate card), depending on how many build/release events you ingest.

1. In Dynatrace, open OpenPipeline:
   • Go to OpenPipeline > Logs > Pipelines > AzureDevOps.
   • Navigate to the Data Extraction section.
2. Next, create a Business Event Processor rule, for all build events, using the following parameters:
   • Name: Build Result
   • Matching condition: matchesPhrase(eventType,"build.complete")
   • Event type: field name eventType
   • Event provider: Change to Static String: AzureDevOps
   • Fields to extract: result, buildNumber, resource.reason

1. Finally, we use another Business Event Processor rule, to extract release events:
   • Name: Release Result
   • Matching condition: matchesPhrase(eventType,"ms.vss-release.deployment-completed-event")
   • Event type: field name eventType
   • Event provider: Change to Static String: AzureDevOps
   • Fields to extract: stageName, projectName, releaseName, releaseStatus, resource.deplyoment.startedOn, resource.deployment.completedOn

Extract Davis® AI events (optional)

Besides transforming the log line into SDLC events, you can also extract Davis events in case something goes wrong. These events can be used to create an alert or trigger a (remediation) workflow.

1. First, add an event if a build has failed. Add a new “Davis event” processor using the following data:
   • Name: Build Complete Failed
   • Matching condition: matchesPhrase(eventType,"build.complete”) AND result== “build”
   • Event description: Unable to generate build {buildNumber}

Note: You can change the event.type in case you want to increase the severity level.

2. Next, extract a Davis event if the deployment is rejected:
   • Name: Release deployment rejected
   • Matching condition: matchesPhrase(eventType,"ms.vss-release.deployment-completed-event”) AND releaseStatus== “rejected”
   • Event description: Unable to deploy release {releaseName}

Discard logs (optional)

Now that we have successfully converted the log event into a SDLC (Business) and a Davis event, you can disable the storage assignment rule. This will reduce the amount of data stored in Grail and help you saving some money (and consequently speeding up your log queries). Go to OpenPipeline > Logs > Pipelines > AzureDevOps.

1. Open the OpenPipeline app and select the pipeline we created before.
2. Select the tab Storage and change the matching condition to false.

Analyzing data

After deleting the logs events we need to adapt our dashboard to consume business instead of log data. To speed up things you can upload a ready-to-use dashboard into your environment:

1. Go to the AzureDevOps Git Repository and download the AzureDevOps Dashboard (on BizEvents).json file.
2. Within Dynatrace, open the Dashboards, select Upload at the top left corner, and select the JSON file.

Additionally, we recommend that you create a segment to filter all of your monitored entities across different apps.

1. Go to the Segments app and create a new segment by selecting + in the top right corner.
2. Rename the segment to AzureDevOps.
3. Select + Business events and add the following filter: event.provider = AzureDevOps
4. Select + Logs and add the following filter: dt.system.bucket = azure_devops_logs
5. Select Preview to validate the filters and Save once you’re done.

What’s next

By following these steps, you’ll be able to seamlessly integrate Azure DevOps with Dynatrace, enabling efficient log management and insightful data visualization.

Happy monitoring! 🚀

The post Insights into your Azure DevOps pipelines appeared first on Dynatrace news.

As modern multicloud environments become more distributed and complex, having real-time insights into applications and infrastructure while keeping data residency in local markets is crucial. Dynatrace on Microsoft Azure allows enterprises to streamline deployment, gain critical insights, and automate manual processes. The result? Optimized performance and enhanced customer experiences.

As of October 2024, Dynatrace is available on Microsoft Azure Australia East region, enabling joint customers to maintain a local SaaS presence. For Dynatrace customers, this means their data and end users in the region will benefit from faster time to value and deeper integration with the Microsoft technology stack to help comply with local data privacy and security requirements.

The move to cloud and data residency in local markets

One of the most significant advantages of this launch is maintaining data residency in local markets. By keeping data within the region, Dynatrace ensures compliance with data privacy regulations and offers peace of mind to its customers. This local SaaS presence minimizes latency and maximizes the speed and reliability of data access.

As a SaaS vendor, Dynatrace carefully manages its deployments across different regions, assuring the efficient and optimal use of infrastructure to serve and support Dynatrace platform customers. The regional reach of the Dynatrace AI-powered platform as a SaaS on Microsoft Azure has now expanded to Australia.

Transforming enterprise operations with Azure Native Dynatrace Service

With the availability of the Dynatrace platform on Microsoft Azure in Australia, regional customers are also able to take advantage of the integration of Azure Native Dynatrace Service.

This integration provides customers with a streamlined and automated setup and configuration of Dynatrace through the Azure marketplace/portal. Additionally, customers are able to maximize their Microsoft investment leveraging Microsoft Azure Consumption Commitment (MACC) to purchase Dynatrace directly through the Azure marketplace.

“Our partner Dynatrace works alongside Microsoft to provide deep insights and automation across the technology stack to enhance operational efficiency for organizations. The Azure Native Dynatrace Service, available in Azure Marketplace, uses Microsoft Azure AI and Dynatrace AI observability to ensure enterprise applications and services are high-performing, reliable, and secure.”

– Yvonne Muench, Sr. Director - Marketplace & ISV Journey, Microsoft

Maximize your cloud estate with AI-powered observability and security

If you’re an existing Dynatrace customer, please contact us to learn how to upgrade to Azure Native Dynatrace Service. An overview of how to upgrade is also available in our guide, Upgrade to Azure Native Dynatrace Service. Or, contact our team to discuss your specific use case. Dynatrace offers a comprehensive set of services to support your migration to the cloud.

Get started with the AI-powered Dynatrace platform on Microsoft Azure in Australia

Interested in exploring the benefits of Azure Native Dynatrace Service? Start by visiting the Azure Marketplace or contact us for more information.

The post Dynatrace on Microsoft Azure in Australia enables regional customers to leverage AI-powered observability appeared first on Dynatrace news.

Dynatrace has partnered with the Microsoft Azure App Service team to seamlessly integrate enhanced observability with Linux App Service using the powerful Sidecar Pattern for containerized computing. This integration simplifies monitoring and management, allowing organizations to focus on delivering exceptional user experiences.

What is the Sidecar Pattern for observability?

Traditionally, integrating monitoring into a main application container requires modifications to the container itself. Like the sidecar on a motorcycle, sidecar containers attach additional services and features to a parent container application without being tightly coupled. With the Sidecar Pattern for Linux App Service, Dynatrace uses a declarative approach, making integration smoother and more efficient, greatly simplifying monitoring within serverless containerized applications.

Here’s how it works:

Separation of concerns. In the Sidecar Pattern, the monitoring agent (the “sidecar”) runs alongside the application container. It handles tasks like collecting metrics, tracing requests, and capturing logs independently.

Decoupled integration. By keeping monitoring separate from the main application, there is no interference with the core codebase. No more tangled dependencies!

Flexibility. Need to add or update monitoring tools? Simply modify the sidecar container without touching the application code.

Benefits of Dynatrace with sidecars

Following is a few of the benefits of the Dynatrace Sidecar Pattern for Linux App Service.

Effortless integration. As a Microsoft Azure Native ISV Services partner, Dynatrace integrates seamlessly with Microsoft Linux App Service, allowing organizations to focus on building exceptional applications.

Improved scalability. Sidecars scale independently, ensuring that monitoring resources adapt to an application’s needs.

Enhanced observability. Dynatrace provides real-time insights into application performance, dependencies, and bottlenecks. Troubleshoot faster and optimize with confidence.

Zero downtime. Deploy updates to monitoring tools without disrupting applications. The Sidecar Pattern ensures uninterrupted service.

Get started with the Dynatrace Sidecar Pattern for Linux App Service

As a Microsoft Azure Native ISV Services partner, Dynatrace is constantly enhancing the features and services we offer to our Microsoft Azure customers.

The Dynatrace partnership with Microsoft is rooted in our deep technical collaboration. This solid foundation enables us to push the boundaries of innovation, bringing cutting-edge solutions to the market that empower our customers to achieve their strategic business goals. Through our partnership, we drive digital transformations and deliver greater business value, ensuring our customers can continue to excel in their respective industries. Together, we are shaping the future of technology and business.

The Sidecar Pattern for Linux App Service is currently in public preview. Learn how to integrate Dynatrace via sidecars through the Microsoft Azure portal in Microsoft’s latest blog.

The post Dynatrace now supports Microsoft Azure Linux App Service with sidecar pattern for enhanced observability appeared first on Dynatrace news.

Dynatrace platform’s unique features are now available on Azure

As of today, Azure customers can leverage the latest Dynatrace core innovations on Microsoft Azure, including:

• Dynatrace Grail™ data lakehouse unifies the massive volume and variety of observability, security, and business data from cloud-native, hybrid, and multicloud environments while retaining data context to deliver instant, cost-efficient, and precise analytics.
• Dynatrace^® AutomationEngine features a no- and low-code toolset and leverages Davis^® AI to empower teams to create and extend customized, intelligent, and secure workflow automation across cloud ecosystems.
• Dynatrace^® AppEngine features a no- and low-code toolset and leverages Davis AI to empower teams to easily create and share custom, intelligent, and secure apps that leverage insights from data generated by their clouds.
• The new Dynatrace user experience, including powerful dashboarding capabilities and interactive Dynatrace Notebooks, drives tighter cross-team collaboration and enables more people within the organization to make data-backed decisions.

Azure Native Dynatrace Service allows easy access to new Dynatrace platform innovations

Dynatrace has long offered deep integration into Azure and Azure Marketplace with its Azure Native Dynatrace Service, developed in collaboration with Microsoft. With the AI-powered Dynatrace platform now generally available on Azure, Azure Native Dynatrace Service customers can now leverage the full AI power of the Dynatrace platform directly from Azure. With Dynatrace directly connected to your Azure subscriptions, Dynatrace OneAgent^® can be deployed directly to VMs and App Services from the Microsoft Azure Portal. One-click activation of log collection and Azure Monitor metric collection in the Microsoft Azure Portal allows instant ingest of Azure Monitor logs and metrics into the Dynatrace platform. For more details, see the blog post, Set up AI-powered observability for your Microsoft Azure cloud resources in just one click.

The following figure shows the benefits of Azure Native Dynatrace Service. For more details, please see the blog post Dynatrace and Microsoft Azure integrate to help accelerate your cloud transformation.

Using the Dynatrace platform on Azure allows Azure Native Dynatrace Service customers to get instant insights into their workloads with a comprehensive set of new innovative features with the best product experience from the Microsoft Azure Portal:

• The Dynatrace platform is automatically provisioned as part of the Azure Marketplace purchase process, allowing you to set up observability for workloads in minutes.
• Configuring the Dynatrace platform and deploying Dynatrace OneAgent from the Microsoft Azure Portal ensures that observability data from Azure resources arrives in Dynatrace within seconds.
• New Dynatrace platform features—with the Grail data lakehouse at their core—allow you to easily query and get insights into your workloads with the new Dynatrace user experience using DQL, Notebooks, and Dashboards, driven by a new Automation Engine, and AppEngine.

Leverage Dynatrace to get observability into all resources in your Azure tenant

This blog post shows you how the Dynatrace platform, together with the Azure Native Dynatrace Service—and unique new capabilities such as Grail, Dashboards, Notebooks, and the Cloud app—can give instant insights into all the Azure resources deployed in your Azure tenant.

Set up complete monitoring for your Azure subscription with Azure Monitor integration

After activating the Azure Native Dynatrace Service (see Dynatrace Documentation for details), the Azure Monitor integration is enabled easily via the Microsoft Azure Portal, as shown in the following screenshot. There’s no need for configuration or setup of any infrastructure.

Enabling the Azure Monitor integration in the Microsoft Azure Portal triggers the linked Dynatrace environment to start polling metrics and resource metadata for the Dynatrace Smartscape^® topology model. Furthermore, as shown in the above screenshot, the collection of resource logs and activity logs is easy to turn on.

Integrate multiple Azure subscriptions under a single Dynatrace environment

If you have multiple Azure subscriptions in your Azure tenant, it’s best practice to integrate the Azure subscriptions with a single Dynatrace environment. Establishing a single source of truth for all observability data reveals the full power of the Dynatrace platform by querying all data with comprehensive new capabilities from the one Dynatrace Grail data lake house for data storage.

To monitor multiple subscriptions within your Azure tenant

1. Create a new Dynatrace environment within the first subscription by creating the first Dynatrace resource (Option Create a new Dynatrace environment as shown in the following screenshot).
2. Then, create a Dynatrace resource in all other Azure subscriptions and link the Dynatrace environment created in Step 1 (the option Link Azure subscription to an existing Dynatrace environment is shown in the following screenshot).

More information can be found at Dynatrace link to existing. Also, see how to automate this process with bicep and how to automate with Azure CLI.

Azure use cases with Dynatrace Apps

The following new Dynatrace^® Apps can be leveraged to get instant insights into all Azure resources of Azure subscriptions connected via the Azure Native Dynatrace Service:

• Clouds enables cross-subscription and cross-region observability in one place.
• Dashboards leverages the power of DQL for Azure monitoring in one place.
• Notebooks offers advanced Azure observability analytics with DQL.

Clouds

Clouds allows easy investigation and troubleshooting of all Azure resources from the subscriptions previously connected to Dynatrace.

The following screenshot shows that you can easily search for resources by name, resource type, region, and tags across all connected Azure subscriptions.

Clouds provides resource properties, metrics, problems, and events in a single view, as shown below.

Davis AI automatically analyzes ongoing problems with your resources. Clouds makes it easy to search for all resources affected by detected problems and navigate directly to the problem details.

Clouds also supports getting the necessary insights for cloud governance. For example, Dynatrace uses automatic tagging to mark the user who created an Azure resource. Searching for all resources with a specific tag (for example, created-by) across your connected Azure subscriptions is easy with Clouds.

Dashboards

Dashboards provides new dashboarding capabilities powered by the new Dynatrace platform query language (DQL), which fully leverages the new Dynatrace experience.

With DQL and Dashboards, combining all observability data in one dashboard is easy. For example, it’s possible to combine resource metadata, resource health from activity logs, Azure Monitor metrics, Davis AI problems, OneAgent process details, Synthetic monitoring results, and much more in a single view, as shown below.

For each section, it’s possible to drill down for detailed context and learn the underlying DQL query.

The following shows a simple DQL summarizing all Azure Virtual Machine cores in the connected Azure subscriptions. By querying the Dynatrace entity model, cores are summed up from entity metadata.

fetch dt.entity.azure_vm
| parse azureVmSize, "KVP{LD[a-zA-Z]+:key'='(LONG:valueLong | STRING:valueStr)','?}:vmsize"
| fieldsAdd cores =   vmsize[`numCores`], memoryMb =   vmsize[`memoryMb`]
| summarize Cores = sum(cores)

Notebooks

Dynatrace Platform offers Notebooks, which allows advanced ad-hoc analysis of Azure environments based on metrics, logs, spans, events, and entities.

The following DQL from Notebooks queries data for all recent Azure health events and aggregates all resource health events from all Azure subscriptions connected via the Azure Native Dynatrace service.

fetch logs //, scanLimitGBytes: 500, samplingRatio: 1000
| filter matchesValue(cloud.provider, "Azure")
| filter azure.resource.type == "MICROSOFT.COMPUTE/VIRTUALMACHINES" or azure.resource.type == "MICROSOFT.COMPUTE/VIRTUALMACHINESCALESETS/VIRTUALMACHINES"
| parse content, "JSON:json"
| fieldsAdd operationName=json[operationName],
category=json[category],
resultType=json[resultType],
callerIpAddress=json[callerIpAddress],
action=json[identity][authorization][action] ,
principalId=json[identity][authorization][evidence][principalId] ,
principalType=json[identity][authorization][evidence][principalType] ,
name=coalesce(json[identity][claims][name],json[identity][claims][xms_mirid]),
time= json[time],
title=json[properties][title],
details=json[properties][details],
current=json[properties][currentHealthStatus],
previous=json[properties][previoustHealthStatus],
type=json[properties][type],
cause=json[properties][cause]
| filter  category== "ResourceHealth"
| fieldsKeep  time, title, details, type, cause, azure.resource.name
| sort  time desc

Utilizing the Dynatrace platform to observe your Azure subscriptions allows you to address compliance requirements beyond the standard; for example, the retention period for Azure activity logs is 90 days. With Dynatrace, you can configure up to a 10-year retention period in Dynatrace Grail (for full details, see data retention periods).

Here are further examples that show the power of DQL and Grail for Azure analysis:

Count the number of VMs per Azure Subscription

fetch dt.entity.azure_vm
| fieldsAdd  azure_subscription = accessible_by[dt.entity.azure_subscription][0], azure_region = belongs_to[dt.entity.azure_region]
| lookup [fetch dt.entity.azure_subscription | fieldsAdd name = entity.name ,  uuid = azureSubscriptionUuid], sourceField:azure_subscription, lookupField:id, prefix:"azure.subscription."
| lookup [fetch dt.entity.azure_region | fieldsAdd name = entity.name], sourceField:azure_region, lookupField:id, prefix:"azure.region."
| summarize  count=count(), by: azure.subscription.name

Count the number of VMs per Azure region

fetch dt.entity.azure_vm
| fieldsAdd  azure_subscription = accessible_by[dt.entity.azure_subscription][0], azure_region = belongs_to[dt.entity.azure_region]
| lookup [fetch dt.entity.azure_subscription | fieldsAdd name = entity.name ,  uuid = azureSubscriptionUuid], sourceField:azure_subscription, lookupField:id, prefix:"azure.subscription."
| lookup [fetch dt.entity.azure_region | fieldsAdd name = entity.name], sourceField:azure_region, lookupField:id, prefix:"azure.region."
| summarize  count=count(), by: azure.region.name

Identify the VMs with top CPU usage

timeseries max= max(dt.cloud.azure.vm.cpu_usage),      
 by:  {dt.entity.azure_vm}
| fieldsAdd maxCpu = arrayMax(max)
| sort maxCpu desc
| lookup [fetch dt.entity.azure_vm | fieldsAdd name = entity.name, azure_subscription=accessible_by[dt.entity.azure_subscription][0],  azure_region=belongs_to[dt.entity.azure_region] ], sourceField:`dt.entity.azure_vm`, lookupField:id, prefix:"azure.vm."
| lookup [fetch dt.entity.azure_subscription | fieldsAdd name = entity.name ,  uuid = azureSubscriptionUuid], sourceField:azure.vm.azure_subscription, lookupField:id, prefix:"azure.subscription."
| lookup [fetch dt.entity.azure_region | fieldsAdd name = entity.name], sourceField:azure.vm.azure_region, lookupField:id, prefix:"azure.region."
| fieldsKeep   maxCpu,azure.vm.name, azure.subscription.name, azure.region.name
| limit 20

Get the latest 10 log lines from Azure

fetch logs | filter cloud.provider == "Azure" or cloud.provider == "azure" | sort  timestamp desc  | limit 10

Upgrade to Dynatrace for Azure

If you’re an existing Dynatrace customer, please contact us to learn how to upgrade to Dynatrace on Azure. An overview of how to upgrade to Dynatrace is available in our guide, Upgrade to Dynatrace SaaS.

Get started with the AI-powered Dynatrace platform and Azure Native Dynatrace Service

Visit the Azure marketplace to start a trial of the Dynatrace platform on Azure and the Azure Native Dynatrace Service.

Please see Data Security Controls in Dynatrace documentation for an overview of the Azure regions currently supported by Dynatrace.

The post Discover the power of the Dynatrace platform on Azure with Azure Native Dynatrace Service appeared first on Dynatrace news.

Dynatrace is proud to provide deep monitoring support for Azure Linux as a container host operating system (OS) platform for Azure Kubernetes Services (AKS) to enable customers to operate efficiently and innovate faster. This integration is a result of our collaboration with Microsoft to better serve our Azure customers across the Microsoft portfolio.

What is Azure Linux?

Azure Linux is a lightweight container host operating system (OS) that includes only the packages needed for container workloads. Microsoft initially designed the OS for internal use to develop and manage Azure services. Today, it’s a generally available container host for AKS and AKS-HCI.

The core operating system has a lightweight footprint of only a few hundred MBs when uncompressed, yet it is powerful enough to support various profiles, including x64 or Arm64-based architectures. Microsoft designed the kernel and other aspects of the OS with an emphasis on security due to its focused role in executing container workloads. This design approach helps eliminate the need to patch and maintain essential packages. Furthermore, the OS enables rapid deployment of containers as applications scale up or down in Kubernetes.

Why monitor Azure Linux container host for AKS?

Azure Kubernetes Services (AKS) is Microsoft’s managed Kubernetes (k8s) service that allows organizations to deploy and manage their containerized workloads quickly. Now, organizations can deploy Azure Linux node pools in a new cluster, add Azure Linux node pools to existing Ubuntu clusters, or even migrate Ubuntu nodes to Azure Linux nodes. However, providing observability into an AKS cluster and its node pools can be complex. Tracking the availability, health, and resource utilization of the underlying Kubernetes infrastructure is essential for several reasons.

• Resource utilization management. Ensure the cluster has enough resources to deploy new applications and deal with demand surges or node failures while avoiding impacts on the existing workload.
• Node and workload health. Visibility of the lifecycle of k8s objects (pods, services, nodes) and associated events is needed.
• Performance. Monitoring the performance of the Azure Linux OS platform is critical to ensure that containerized workloads are running efficiently and effectively. Performance monitoring can help identify bottlenecks, optimize resource usage, and prevent downtime.
• Security. Azure Linux is designed to be highly secure, but monitoring the OS is critical to ensure it remains secure. Security monitoring can help detect and prevent security breaches, identify vulnerabilities, and ensure compliance with regulatory requirements.

Jim Perrin, Principal PM, Microsoft Azure Linux at Microsoft said, “With Azure Linux, customers see benefit from the value of having a secure, performant, and fully native AKS container host. Microsoft controls the supply chain for Azure Linux end to end, resulting in a more streamlined image tailored and optimized for AKS. Azure Linux provides a consistent k8s experience throughout the developer and production lifecycle coupled with the level of support you expect from Microsoft.”

How Can Dynatrace Monitor Azure Linux container host for AKS?

Dynatrace offers continuous automation and comprehensive observability for the entire stack in Kubernetes without requiring any modifications to code, container images, or deployments, setting it apart as the sole monitoring solution of its kind. Deploying through the Dynatrace Operator in Kubernetes environments enables application teams to confirm that their applications deliver the anticipated value and performance while giving them an understanding of their application’s behavior.

With insights into Azure Linux OS-based Kubernetes node pools, Dynatrace can quickly assess the following.

• Cluster resource utilization to ensure business continuity while controlling costs.
• Pod and workload overview to quickly identify unexpected differences in application and microservice instances.
• All native Kubernetes events to diagnose common platform problems such as crash loops, failed image pulls, and out-of-memory containers.
• Instantly visualize the Kubernetes environment with all the detailed metrics and events teams care about.

An example dashboard for Kubernetes workload might look like the following.

Indeed, Dynatrace continuously maps the interdependencies between these entities. At the same time, Dynatrace AI engine, Davis® saves additional time and resources by automatically identifying and prioritizing alerts from Kubernetes applications and infrastructure.

AI-powered observability for clusters, pods, and microservices

With Davis, the Dynatrace AI engine prioritizes anomalies in these environments in real time, detailing the root cause of issues impacting end users. This saves infrastructure and application teams time and resources and empowers them to act collaboratively. Dynatrace’s radically different AI determines the following.

• The functional root cause of a performance or availability problem, including code-level visibility.
• The foundational root cause is the deployment or configuration change responsible.
• The impact on real users and business KPIs.

Here’s an example of a Problem card that Davis opened because of an increased failure rate in the workload called order service. Not only did it identify the business impact of this failure, but it also identified any upstream or downstream services, which in this case was an upstream service called front end.

Intuitive view on Kubernetes node utilization

Quickly identify node pools with unexpected resource utilization or excessive pod-level resource limits. Identify pending and failed pods in workloads and filter by namespace and workload type.

• Launch an analysis from a natural starting point with the node pools in mind.
• Identify and diagnose nodes that are being CPU or memory challenged.
• Quickly locate all nodes in the Kubernetes cluster.

Here’s an example of a node in the AKS cluster that Davis identified as having a Memory Pressure condition on one of the nodes, indicating that it is running low on memory.

Modern cloud done right.

With Dynatrace support for Azure Linux container host for AKS, organizations can achieve greater visibility into their containerized workloads and ensure their digital ecosystems’ optimal performance and security.

Dynatrace also has many other Azure services, such as Virtual Machines, Functions, App Services, Spring Cloud, Service Fabric, and Virtual Machine Scale Sets.

To learn more about Azure Linux container host for AKS read Microsoft’s blog.

The post Dynatrace adds monitoring support for Microsoft Azure Kubernetes Service deployments using Azure Linux container host appeared first on Dynatrace news.

Over the last few years, Dynatrace and Microsoft have partnered to help the world’s largest organizations tame hybrid, multicloud complexity and accelerate digital transformation. Some time ago, we announced monitoring coverage for all Azure Monitor services, as well as the ability to purchase the Dynatrace Software Intelligence Platform through the Microsoft Azure Marketplace. Now, Dynatrace and Microsoft have further deepened their partnership by making Dynatrace for Azure generally available. Dynatrace for Azure provides all the unique capabilities of the Dynatrace Software Intelligence Platform on Microsoft Azure with native integration into the Azure Portal.

Using Dynatrace on Microsoft Azure allows customers to leverage all the benefits of the Dynatrace platform’s underlying cloud-native, web-scale architecture while operating entirely in the Azure cloud.

Furthermore, Dynatrace for Azure native integration gives Microsoft Azure customers a seamless experience for Dynatrace automatic and intelligent observability and runtime application security in and from Azure. The benefits of this native integration include:

• Integrated onboarding: You can provision Dynatrace and manage the integration through the Azure Marketplace and Portal. The seamless onboarding experience sets up Dynatrace automatically. Monitoring the health and performance of your workloads—whether based in Azure or other cloud providers—is established in minutes with just a few clicks. Monitoring of selected Azure resources in your Azure subscription is established automatically.
• Unified billing: You can purchase Dynatrace via the Azure Marketplace—you can even spend your organization’s Microsoft Azure consumption commitment. Dynatrace costs are reported through Azure monthly billing, making it easier to procure and align Azure and Dynatrace sales.

• Single sign-on: You can easily enable SSO through Azure Active Directory—there’s no need for separate authentication to the Dynatrace portal. This improves security and compliance and creates a single source for troubleshooting, performance optimization, and cross-team collaboration.
• Metrics and Logs: You can enable the collection of metrics and logs for Virtual Machine (VM) and App Services resources by installing Dynatrace OneAgent on those resources. Furthermore, you can activate the sending of Azure subscription activity logs and resource logs to Dynatrace.

• OneAgent deployment: You can install or uninstall Dynatrace OneAgents on single or multiple virtual machines and Azure App Services directly from your Azure Portal.

• Manage Dynatrace within Azure Portal: Within your Azure Portal, you can verify which resources are sending Azure metrics and logs to Dynatrace and make instant changes as needed.

• Deeper Azure CLI integration: You can easily manage Dynatrace resources from the Azure CLI to further extend deployments of those resources with ARM templates or other third-party IAAC platforms, such as Terraform.

Dynatrace and Microsoft expand their partnership

“Microsoft is committed to providing a complete and seamless experience for our customers on Azure,” says Balan Subramanian, Partner Director of Product Management, Azure Developer Experiences, Microsoft. “Enabling developers to use their most loved tools and services makes them more productive and efficient. Azure native integration of Dynatrace makes it effortless for developers and IT administrators to monitor their cloud applications with the best of Azure and Dynatrace together.”

By providing customers with the most comprehensive, intelligent, and easy-to-deploy observability solution in the market, Dynatrace and Microsoft have laid the groundwork for organizations to successfully migrate to cloud environments and continuously modernize with speed and scalability.

“Deep and broad observability, runtime application security, and advanced AI and automation are key for any successful cloud transformation,” said Dynatrace Senior Vice President of Product Management, Steve Tack. “Through the Dynatrace platform’s integration with the Microsoft Azure Portal, customers now have immediate access to these capabilities. This integration delivers answers and intelligent automation from the massive data volume generated by modern hybrid-cloud environments, which enables flawless and secure digital interactions.”

How to get started

The collaboration and native integration between Dynatrace and Microsoft—which is now generally available for all Dynatrace and Azure customers—makes it easier than ever to use the Dynatrace platform’s observability, security, AI, and automation to enable your successful cloud journey. You can check out the new Azure integration on the Azure Marketplace. For further information, don’t hesitate to contact us.

The post Dynatrace and Microsoft Azure integrate to help accelerate your cloud transformation appeared first on Dynatrace news.

As part of our partnership with Microsoft, Dynatrace is excited to announce our new Prometheus Extension for Apache Cassandra. This extension provides fully app-centric Cassandra performance monitoring for Azure Managed Instance for Apache Cassandra.

Apache Cassandra is an open source, distributed, NoSQL database. Because of its scalability and distributed architecture, thousands of companies trust it to run their cloud and hybrid-based workloads at high availability without compromising performance.

Cassandra is also essential to Dynatrace because it is integral to our monitoring solution. This makes Dynatrace a natural Microsoft launch partner for Azure’s Managed Instance for Apache Cassandra Service. As a part of this partnership, we are proud to announce the release of Dynatrace’s Cassandra Prometheus Extension.

Azure Managed Instance for Apache Cassandra vs Azure Cosmos DB Cassandra API

Microsoft Azure offers multiple ways to manage Apache Cassandra databases.

Azure Managed Instance for Apache Cassandra provides the ability to provision managed Apache Cassandra clusters on Azure. You can also quickly scale out the capacity of your existing on-premises or cloud self-hosted Apache Cassandra clusters. It also removes the need for developers and database administrators to manage infrastructure or update database versions.

Azure Cosmos DB Cassandra API is a compatibility layer over Microsoft’s globally distributed cloud-native database service, Azure Cosmos DB. This enables Apache Cassandra drivers and applications to use Azure Cosmos DB as a cloud-native, fully managed NoSQL database service.

These two Azure services in combination enable Apache Cassandra customers to adopt a solution that simplifies hybrid cloud complexity.

Seeing the value

Once you deploy the Dynatrace extension, Dynatrace ingests your Cassandra metrics and analyzes them in context with the entire stack. Then the extension adds a preconfigured dashboard, topology entities and relationships, and entity screens to your environment. You can use the dashboard “Azure Managed Instance for Apache Cassandra Overview” as a launch point for your Cassandra monitoring.

From the main dashboard, you get a quick snapshot of your clusters and how they’re performing.

From there, you can dive deeper into infrastructure metrics (cluster, datacenter, racks, and nodes) and data metrics (keyspaces and tables).

In addition to the built-in views, Dynatrace provides data analysis that enhances your ability to query and chart metrics. For example, the Dynatrace Data Explorer enables you to do the following:

• Analyze multidimensional metrics, whether built into Dynatrace or ingested from other sources like Azure Monitor.
• Choose from any of nine visualizations: graph, stacked column, stacked area, pie, single value, table, top list, heatmap, or honeycomb.
• Add your visualization to your dashboards for easy access and sharing.
• Provide a foundation for calculating metrics in dashboard charts.

With the Dynatrace Data Explorer, you can easily analyze metrics, such as client read/write latency by Cassandra nodes and disk space usage by keyspaces. You can also analyze table metrics, such as cache hits and misses.

Precise AI-powered answers for Azure Managed Instance for Apache Cassandra

Analyzing data for fast troubleshooting can be very complex due to the large amounts of data and variety of data sources. Rather than processing simple time-series data, Dynatrace Davis®, our AI causation engine, maps data to a unified entity model using metrics, traces, logs, and real user data. Davis gives your operations team specific answers about the root cause of problems so you can prioritize and resolve issues.

Below is an example of a Dynatrace problem card, which shows how a spike in Cassandra write latency impacts your application.

Start monitoring Azure Managed Instance for Apache Cassandra

Use Dynatrace to monitor all of your Azure Managed Cassandra instances. Then you can easily visualize performance issues and determine the root cause of problems.

To get started, sign up for a free 15-day trial.

The post Dynatrace supports Azure Managed Instance for Apache Cassandra appeared first on Dynatrace news.

More than 95% of Fortune 500 companies use Microsoft Azure. Azure provides a wide variety of cloud services with globally distributed applications. Running containers in the cloud is also a very popular use case for Azure. Because all these resources generate huge amounts of data in various locations, it makes it difficult to monitor. These challenges make Azure observability critical for building and monitoring cloud-native applications.

Observability in the cloud can be hard to achieve. There is increasing complexity when it comes to scaling hybrid, multicloud environments. Because the number of dependencies rapidly increases, lack of visibility becomes a major pain point. This is especially true when it comes to identifying root causes to remediate large-scale incidences quickly.

Observability means how well you can understand what is happening in a system by collecting metrics, logs, and traces. Observability is so important because it is the crux of monitoring and goes beyond IT as it safeguards consumer and business expectations are met.

Let’s dive into what Azure observability means and why it matters.

What is Azure observability?

Microsoft provides guidance to accelerate cloud adoption with The Cloud Adoption Framework. By using Cloud Adoption Framework best practices, organizations are better able to align their business and technical strategies to ensure success.

One of the key monitoring strategies in the Cloud Adoption Framework is observability. Microsoft believes observability enables monitoring. Once you achieve initial observability, you can develop actionable alerts, create useful dashboards, and evaluate AIOps solutions. This allows you to get comfortable with all the underlying metrics and log data.

Why Azure observability matters

As organizations adopt more cloud-native technologies, infrastructure and application monitoring can get complex. When it comes to Microsoft Azure, it’s about understanding the application workloads and Azure infrastructure. When you have visibility into the Azure infrastructure, you can troubleshoot more effectively to ensure that critical applications are functioning optimally.

This visibility also ensures there are no performance issues with customer-facing transactions or internal applications critical to your business. You can’t monitor what you don’t know. Accordingly, awareness of the full technology stack requires observability of applications, their services, and transactions down to the code level. Observability of Azure infrastructure and all the services it supports helps you pinpoint performance issues and eliminate guesswork.

Best in class observability for Microsoft Azure—and beyond

As organizations shift to hybrid cloud environments, Microsoft Azure adoption rates have been skyrocketing. For most organizations, Azure infrastructure is a critical part of a wider IT infrastructure. Driving innovation to ensure that services are always available and running optimally requires observability that extends beyond the Azure infrastructure into the full IT stack.

With AI at its core, the Dynatrace platform unifies application and infrastructure monitoring across all your IT operations infrastructure. As a result, Dynatrace simplifies cloud operations, automates DevSecOps, and integrates with all major cloud platforms and technologies. With a single source of observability intelligence, teams can optimize CI/CD pipelines, deliver on performance and application security objectives, and focus on improving digital experiences for their users.

Dynatrace is a Microsoft gold partner and Cloud Platform competency holder. The Dynatrace platform is generally available as a SaaS solution on Azure providing automated cloud observability. Through auto-instrumentation, Dynatrace supports end-to-end tracing for Azure functions and brings value by enriching the data from Azure Monitor and Application Insights. By extending Azure observability into the platform with additional metrics for cloud infrastructure, Dynatrace integrates Azure infrastructure with load balancers, API Management Services, and more. This extended observability improves operations, reduces MTTR, and increases innovation.

The post Microsoft Azure observability enables full stack performance appeared first on Dynatrace news.

As organizations adopt microservices architecture with cloud-native technologies such as Microsoft Azure, many quickly notice an increase in operational complexity. These complexities lead organizations to fundamentally transform the way they approach their observability capabilities in a dynamic multicloud environment. To guide organizations through their cloud migrations, Microsoft developed the Azure Well-Architected Framework.

Most monitoring tools for migrations, development, and operations focus on collecting and aggregating the three pillars of observability—metrics, traces, and logs. But managing these three data types at a scale becomes unsustainable for even the most experienced teams.

In a dynamic cloud environment, an organization undergoing cloud migration must go beyond the three pillars of observability by:

• Monitoring service level objectives (SLOs) before and after migration
• Analyzing user experience to ensure uniform performance after migration
• Getting precise root cause analysis when dealing with several layers of virtualization in a containerized world
• Understanding resource utilization for cost management

In this blog, we’ll review the five pillars of the Azure Well-Architected Framework and illustrate how organizations can use Dynatrace to ensure their applications are architected correctly.

What is the Azure Well-Architected Framework?

The Azure Well-Architected Framework is a set of guiding tenets organizations can use to evaluate architecture and implement designs that will scale over time. The Framework is built on five pillars of architectural best practices:

• Cost optimization
• Operational excellence
• Performance efficiency
• Reliability
• Security

Each pillar brings business and technology leaders together to help organizations choose architecture options that best strategically align to their specific business priorities as they begin their cloud journey.

At every step, Dynatrace provides integrations, precise root-cause analysis, and pinpoint precision fueled by AI and automation.

Cost optimization

This pillar of the Azure Well-Architected Framework encourages organizations to align their business goals with return on investment (ROI). Some principles Microsoft provides across this area include:

1. Choosing the right resources aligned with business goals that can handle the workload’s performance.
2. Continuously monitor cost and optimize your capacity needs.
3. Utilize Azure SaaS and PaaS resources to pay only for resources you consume and increase or decrease usage depending on business requirements.

With Dynatrace’s full-stack monitoring capabilities, organizations can assess how underlying infrastructure resources affect the application’s performance. Using a data-driven approach to size Azure resources, Dynatrace OneAgent captures host metrics out-of-the-box to assess CPU, memory, and network utilization on a VM host. Figure 1 shows various host metrics and other data Dynatrace provides out of the box to help size your Azure host accordingly.

Right-sizing is an iterative process where you adjust the size of your resource to optimize for cost. Doing this on an ongoing basis requires you to monitor your application’s resources and performance health to help you make the cost/benefit analysis. With Dynatrace, you can display utilization metrics across multiple hosts onto a single dashboard to quickly assess which hosts are over and underutilized, as shown in Figure 2.

Operational excellence

The operational excellence pillar of the Azure Well-Architected Framework focuses on implementing best practices to keep an application running in production. To do that, organizations must evolve their DevOps and IT Service Management (ITSM) processes. This involves automating mundane tasks to reduce the chance of human error, proactively catching mistakes before they impact users, and facilitating team collaboration to address operational issues with applications.

Traditional observability solutions offer little information beyond dashboard visualizations. Instead, it remains up to human experts to correlate and analyze the data in time-consuming war rooms. In comparison, the Dynatrace platform reliably takes that burden off human operators by utilizing its causation-based AI engine, Davis. Using high-fidelity metrics, logs, code-level tracing, and a dynamic topology map of your applications, Davis can identify the precise root cause and prioritize its business impact.

Let’s look at an example. In a situation where multiple back-end services impact a single application Davis will generate a single problem incident to identify all the entities impacted. This enables organizations to improve mean time to resolution (MTTR) and avoid alert storms. And since Davis has identified the precise root cause, you can take that data and automatically run a corrective action, as shown in Figure 3, by leveraging Dynatrace’s integrations with:

• Dynatrace’s Cloud automation to understand which changes caused SLO violations
• Incident management tools such as ServiceNow, PagerDuty, xMatters, or OpsGenie
• Collaboration tools such as Slack or JIRA
• Auto-remediation platforms such as Ansible Tower, StackStorm, or ServiceNow

With a single data model, not only can you slice and dice the data across infrastructure, applications, operations, and business data to provide shared context but also improve your organization’s approach to cross-team collaboration.

Performance Efficiency

With the Performance Efficiency pillar of the Azure Well-Architected Framework, organizations must ensure the workloads they modernize and migrate to the cloud are able to scale to meet changes in demand and usage over time. Some principles Microsoft provides to help organizations across this area include:

• Establish performance baselines
• Continuously monitor the application and the underlying infrastructure
• Design efficient use of your computing resources as demand changes and technologies evolves

To make an informed decision on what to optimize within your application, you must first collect baseline performance data. Once you have and understand this data, you can identify issues, find opportunities for improvement, and eliminate risks before you go through a costly migration exercise.

To optimize your back-end systems, you can use the service flow view within Dynatrace to identify layers of application architecture. To understand, reduce, and optimize back-end systems, the service flow diagrams can show common performance problems:

• Too many roundtrips between services
• Too much data requested from a database
• Too many fine-grained services leading to network and communication overhead
• Missing caching layers
• Missing retry and failover implementation

Once you’ve analyzed the service flow of your application, you can drill down into the hotspots view to quickly identify which requests have the slowest response times. Figure 4 shows how Dynatrace automates the analysis of service and service-to-service hotspots. For example, on the left side, we see a breakdown of how much time various types of calls contribute to other services. On the right side, we see the top hotspots Dynatrace identified. By clicking on one of the findings, you can drill deeper to get additional details about the downstream service call:

With the automated analysis of your code hotspots within Dynatrace, you can quickly identify bottlenecks and help you right-size your cloud resources.

Reliability

With the reliability pillar of the Well-Architected Framework, organizations must ensure they build resilient and available applications. Some principles Microsoft provides to help organizations across this area include:

• Define and test availability targets such as service level agreements (SLAs) and SLOs
• Design applications to recover from errors gracefully
• Monitor and measure application health

Figure 5 shows how the Dynatrace Software Intelligence Platform provides several different types of service-level indicators (SLIs) for defining your SLOs. It monitors those objectives’ status and error budgets while providing you with all the facts regarding the business, SLOs, and SLAs, and end-user experience.

The Dynatrace SLO wizard provides guidance and templates for setting up SLOs with the right metrics and combines this with powerful problem root-cause detection and analysis. Davis® provides quick notifications for anomalies it detects with actionable root causes. As a result, when your SLO turns red, Davis has already notified you of the problem showing the root cause.

Once you have defined your SLOs for production reporting, you can also “shift left” to automatically evaluate each phase of the software delivery pipeline using the Dynatrace Cloud Automation module. The concept of “shift-left SRE” introduces SLOs earlier in the lifecycle to improve the quality and speed of your software releases.

Cloud Automation also enhances DevOps and SRE teams’ processes with automated closed-loop remediation of releases that fail in production. In addition, the module provides automatic release inventory and version comparison to evaluate the performance of individual release versions, and as needed, roll back to a previous version. As a result, organizations implementing Dynatrace to monitor their SLAs and SLOs and using that to “shift-left” have increased availability and resiliency within their applications.

To identify application performance issues before real users are affected, organizations should also leverage synthetic monitoring. Dynatrace Synthetic Monitoring simulates users’ activity using major desktops and mobile browsers from locations all around the globe to identify availability and performance, key transaction monitoring (such as login, purchase, checkout). Within synthetic monitoring you can do two types of tests:

• Browser tests where a robot client simulates a transaction with each user click;
• API tests where you can specify endpoints to test a specific workflow from and end-to-end for your application backend.

With synthetic monitoring, organizations can evaluate whether an application meets a specific SLO/SLA for critical business transactions. Moreover, with Dynatrace AI Automation, teams can focus on higher priority problems, which in turn significantly reduces the time teams require to identify and address root causes.

Security

The security pillar of the Azure Well-Architected Framework calls on organizations to think about security throughout the entire lifecycle of an application. Principles that Microsoft provides across this area include:

• Monitor and track security alerts
• Detect threats early and respond quickly
• Block attacks against exposed vulnerabilities
• Reduce your organizational risk

The Dynatrace Application Security module automatically detects, assesses, and remediates open-source and third-party vulnerabilities for Java workloads. The module combines security and observability data to automatically and continuously analyze applications, libraries, and code runtime in production and pre-production.

Figure 6 shows how Dynatrace automatically and continuously monitors any runtime vulnerabilities and provides in-depth answers on the type of vulnerability detected and which exact process was affected.

Collectively with OneAgent, Davis, PurePath, and Smartscape technologies, Dynatrace Application Security builds on these platform strengths to include features such as technologies. The module builds on these platform strengths to include features such as:

• Automatic and continuous vulnerability detection with precise risk and impact assessment to prioritize and focus on what matters the most and 100% runtime visibility
• Deep insights into production execution of open-source components and closed source software and containers.
• Automatically detects and blocks vulnerability attacks in real-time like Log4Shell with no configuration.
• One single platform that drives efficient DevSecOps collaboration and automated vulnerability management

As a result, organizations that adopt Dynatrace Application Security have visibility and security across the entire SDLC, with Davis automatically detecting and blocking any vulnerability.

Dynatrace and Microsoft Azure integrations

Together, Dynatrace and Microsoft help enterprises stay on top of their complex, dynamically scaling Azure cloud environments through integrations and monitoring capabilities. Here is a summary of the growing list of Dynatrace integrations for Azure:

1. Compute – Dynatrace OneAgent provides full-stack monitoring for Azure Virtual Machine and Virtual Machine Scale Sets.
2. Azure Monitor – Fully integrated with entire set of services that publish to Azure Monitor, including Azure Alerts.
3. Serverless – Deploy OneAgent via ARM templates or Site Extensions for Azure App Server or Azure Functions to get code level insights.
4. Containers & Kubernetes (AKS) – Dynatrace OneAgent provides extensive monitoring of Azure Kubernetes Service pods, nodes, and clusters.
5. Azure Service Fabric – Our OneAgent installs as a VM extension on Azure Service Fabric to easily provide full-stack monitoring.
6. Azure Automation – AI-driven anomaly detection of jobs.

As depicted in Figure 7, Dynatrace’s native integration with Azure Monitor collects all the metrics from various Azure services such as virtual machines.

Next steps with Dynatrace and the Azure Well-Architected Framework

Check out Dynatrace’s listing in the Azure Marketplace to see how easy it is to get started. To learn more, check our webinar with Microsoft: Monitor and modernize Azure operations with Dynatrace.

The post Azure Well-Architected Framework: What it is and how to tame it with AI and automation appeared first on Dynatrace news.

I’m often asked by customers and prospects evaluating Dynatrace, “How do I get started integrating Dynatrace into my software delivery pipelines?” and I hope this blog will show you how you can.

More specifically, I’ll demonstrate how in just a few steps, you can add Dynatrace information events to your Azure DevOps release pipelines for things like deployments, performance tests, or configuration changes. This means, your development and operations teams have additional context information during review and analysis of your applications.

Microsoft DevOps Azure is one of the best CI/CD systems and a strategic technical Dynatrace partner. Together, we offer a variety of integrations for Microsoft Azure, as well as the option to host the Dynatrace platform in Azure.

What are Dynatrace information events?

Dynatrace information events enable CI/CD tools, such as Azure DevOps, to provide additional details for Dynatrace. Below we can see both the information (#1) and deployment events (#2) for a service that was the root cause to a problem the Dynatrace AI engine, Davis®, determined.

Information events are also viewable on the entity page. Below (left) is an example deployment event and an example custom information event (right).

There are four Dynatrace information event types: deployment, annotation, configuration, and info. Each event has a timestamp, event source, a few standardized fields (depending on the event type), and the option to add additional custom fields.

Having information events speeds up triage by adding context to what’s happening with the application. Just imagine getting alerted about an issue and immediately seeing a load test or deployment took place, and in one click of the event, URL review the system, job, and team responsible!

What are Dynatrace tags?

When creating information events, you must target the entities to receive the event so that it’s only associated with the relevant component. That is where Dynatrace tags come in.

In a nutshell, tags in Dynatrace are labels or markers used for organizing entities in large monitoring environments. Below shows a few tags for my front-end service; “environment:orders-project-staging”and “service:front-end”.

For custom tags, Dynatrace recommends using automatic tagging rules to reduce maintenance and ensure changing infrastructure is automatically updated with tags.

These rules dynamically match the metadata detected by the Dynatrace OneAgent. Once a match is made, the rule will automatically assign the tag and a ‘tag value’ which is defined in the rule.

For additional information on tagging, check out these resources:

• Tagging 101 – Tagging Essentials Video
• Automated rule based tagging for services blog
• Dynatrace automatic tagging rules documentation

Dynatrace API

The Dynatrace event API is how scripts can automate information event creation. The type of event, event information, and the entities to send the event to are passed in the API request.

As mentioned above, tags are used to match entities for example: “Add a deployment event to the entities with the service tag equal front-end and environment tag equal staging”.

To use the Dynatrace API, you must pass in a Dynatrace API token within the HTTP request header as to secure the API request.  An API token is created within Dynatrace by following the Dynatrace documentation.

Calling the Dynatrace Event API using a PowerShell script

This PowerShell script example below builds up the POST request and calls the Dynatrace events API to add a deployment event.

Let’s break this script down:

1. Dynatrace tenant and API token that is passed in as arguments. We do this as to not hardcode the URL and the API token in the script.
2. The “environment” and “service” tag values are passed in as arguments. You’ll likely have different tag names, and several tags for your environment, so you’ll need to adjust your arguments and script for your requirements.
3. Create variables with the strings and URLs that make up the information event. This script assumes it will be run within Azure DevOps, and by assuming it’ll be run within Azure DevOps, it can use the large number of built-in Azure DevOps release variables for constructing the event title, source and deployment values of the new event.
4. The event API request has a section in the request body for defining the tags to match. This section uses the “environment” and “service” tag arguments passed into the script.
5. Call the Dynatrace API with the API Token and the request body.

Call the PowerShell script from an Azure DevOps release pipeline

To call the PowerShell script, let’s use the following design:

• Use the Azure DevOps PowerShell script task.
• Read the PowerShell script from a GitHub Repo.
• Use DevOps variables for the argument values passed to the script. Variables can also be protected as to not have the API token appear in logs.

STEP 1 – Create a “variable group” for Dynatrace URL and API Token

A variable group can be shared across pipelines in an Azure DevOps project and is perfect for storing the Dynatrace URL and API token.

To add one, navigate to the DevOps project library adding these two variables:

• dynatrace-api-token – use the API token you created for your Dynatrace tenant and click on the “lock” icon to mask this value.
• dynatrace-base-url – use the base URL for your environment for example https://{your-environment-id}.live.dynatrace.com for SaaS or https://{your-domain}/e/{your-environment-id} for managed.

STEP 2 – Link variable group to the release pipeline

Link a variable group within a pipeline variables section as shown below. Notice how the Dynatrace API token value is masked.

STEP 3 – Create variables for tag inputs

Since the tags for the information event are specific to the pipeline, we use release pipeline variables to store these. My PowerShell script expected two, I add variables for “environment” and “service” as shown below.

STEP 4 – Read in PowerShell script from GitHub

To get started, make a copy of my script sample found here and check it into your repository.

1. Within the Azure DevOps release artifact section, choose your GitHub as the source.
2. If you don’t have one, click the manage link to add a DevOps service connection to the GitHub repo.
3. Choose your repo and a branch.

4. In the PowerShell task, adjust the type to “file path” and click the “…” next to “script path”. This will open a popup window for picking the script.

5. Use the file picker to pick the PowerShell script.
6. Finally, add the script arguments for Dynatrace and tag values contained in the DevOps variables we defined above.

STEP 5 – Run the pipeline

After the release pipeline PowerShell task is run, the DevOps log will contain the API response. A successful execution will show the Dynatrace IDs of all custom events created by an event push call as shown below.

Dynatrace shows our new event!

Try it yourself

Try adding Dynatrace tags and events for your environment, and let us know how to you get on! And, check out the other PowerShell scripts in my GitHub repository including adding a CUSTOM_INFO event that can be used for events like “performance test start” and “performance test end”.

If you haven’t tried Dynatrace, check out our Dynatrace Free Trial and Developer Program to help you learn, collaborate, and build on the industry’s powerful Software Intelligence platform along with the rest of your industry colleagues.

The post Get started integrating Dynatrace into your Azure DevOps release pipelines appeared first on Dynatrace news.

“Microservices running in Docker containers are the building blocks of modern cloud-based deployments. However, the hyper-dynamic nature and sheer scale of container environments result in massive complexity that IT operations teams struggle to monitor and manage,” said Steve Tack, SVP Product Management at Dynatrace. “Dynatrace® automatically monitors the applications and services running within containers, along with the host. By seeing all monitoring data in context, operations teams can gain a holistic view of an application’s performance, with comprehensive insight into the performance of their cloud operations. In turn, these insights also allow developers to improve their software architecture.”

Docker containers simplify the process of packaging an application or microservice so it can be easily moved between hosts without requiring changes to the container image. Originally developed for Linux, Docker for Windows now allows for the creation of containers for Windows applications that can be deployed directly on a Windows host. When Dynatrace® is deployed on a Windows host, the software agent automatically detects any Docker containers that are running on that host. Dynatrace® AI builds and maintains a complete real-time dependency map, no matter how large or complex, so IT operations teams can monitor their container applications across networks of hosts or cloud instances.

“Dynatrace was a pioneer in monitoring Docker containers, with support for Docker on Linux since 2015. There’s tremendous demand for Docker on Windows, and Dynatrace is addressing that demand” continued Tack. “Now organizations that use Dynatrace® will be able to deliver better software faster, automate and modernize their cloud operations, and deliver unrivaled user experience, regardless of the platform they choose to deploy on.”

Gabe Monroy, Lead Product Manager for Cloud Native Compute at Microsoft Azure, Microsoft Corp. said, “We’ve seen a lot of excitement from businesses deploying Docker containers for Windows in Microsoft Azure, as it allows for a more seamless way for developers to manage and deploy applications in their cloud environments. As this use proliferates, we are pleased to work with Dynatrace to enable businesses to address monitoring these complex environments with an AI-driven approach for deeper visibility, automated troubleshooting, and real-time remediation.”

To learn more about Dynatrace’s support for Docker for Windows, visit Dynatrace’s booth 1340 at Microsoft Ignite in Orlando, FL from September 24th-28th

The post Dynatrace strengthens its Microsoft Azure visibility with Docker for Windows monitoring support appeared first on Dynatrace news.