Azure Observability Blog articles

Copy dashboards from Dashboards with Grafana to Azure Managed Grafana

aayodeji — Thu, 26 Mar 2026 17:28:43 GMT

Azure Monitor Dashboards with Grafana provides an in‑portal Grafana experience optimized for Azure Monitor and managed Prometheus data.

For many teams, that simplicity is exactly what they need.

As observability practices mature, teams often need more than visualization: broader data source support, stronger security controls, and advanced workflows like Azure Managed Grafana MCP. Until now, moving dashboards from Dashboards with Grafana into Azure Managed Grafana often meant recreating them by hand or exporting JSON, extra friction when teams want to move faster.

The new Copy to Managed Grafana experience removes that friction.

Introducing Copy to Managed Grafana from Azure Monitor Dashboards with Grafana

Why a copy experience was needed

Dashboards with Grafana and Azure Managed Grafana serve complementary roles.

Dashboards with Grafana focuses on:

Fast, zero‑setup visualization
Tight integration with Azure Monitor and Prometheus
An embedded experience directly inside the Azure portal

Azure Managed Grafana extends that foundation with:

Full Grafana workflows, including alerts, reporting, and automation
Support for additional data sources and plugins
Enterprise‑grade security features such as private endpoints and managed identity
Cross‑team reuse through folders, APIs, and Role Based Access Controls

Historically, teams that outgrew Dashboards with Grafana didn’t have a simple, in‑product way to bring their dashboards forward, so continuing in a more advanced Grafana environment required extra manual steps.

The goal is simple: copy dashboards to Azure Managed Grafana as needs grow—while continuing to use Dashboards with Grafana for day‑to‑day work.

Introducing “Copy to Managed Grafana”

Customers can now copy dashboards from Dashboards with Grafana into Azure Managed Grafana directly from the Azure portal—without changing the original dashboard.

This feature is:

In‑context – start from your dashboard in Dashboards with Grafana
Seamless – no exports or re‑creation
Non‑disruptive – keep using the source dashboard while you adopt Managed Grafana

The flow is straightforward:

Select “Copy to Managed Grafana” from your dashboard in Dashboards with Grafana. This feature doesn’t work on built-in dashboards, so you would have to save a copy of built-in Dashboards before you can copy those.
Choose an existing Azure Managed Grafana workspace or create a new one
Complete the copy and continue working in a full Grafana environment, making data connections where needed

You can easily copy to an existing Azure Managed Grafana instance or create a new one

Because it appears where teams already build dashboards, the option is easy to find when it becomes relevant.

Advanced capabilities, like additional data sources, alerts, and folder organization, are configured after copying, so teams can adopt them when they’re ready.

This keeps the transition predictable and avoids surprises.

Dashboards with Grafana is the fastest way to visualize Azure Monitor data with Grafana. When teams need more control, scale, or extensibility, Azure Managed Grafana is the natural next step, without forcing you to stop using Dashboards with Grafana.

Together, they form a single observability journey:

Start quickly with Dashboards with Grafana
Copy dashboards into Azure Managed Grafana when you need more capabilities
Enjoy end to end observability within the Azure ecosystem as requirements evolve

You don’t have to trade speed today for flexibility later.

Learn more by reading the doc: Copy an Azure Monitor dashboard to Azure Managed Grafana - Azure Monitor | Microsoft Learn

Introducing Azure Managed Grafana MCP: The Managed Telemetry Gateway for AI Agents

aayodeji — Thu, 19 Mar 2026 20:10:08 GMT

AI agents are rapidly becoming a core part of how teams build, operate, and improve cloud systems, from coding assistants to autonomous remediation workflows. To deliver on that promise in the enterprise, agents need a secure, governed way to access real production telemetry. Azure Managed Grafana MCP lets AI agents securely query the same production telemetry you already connect to Azure Managed Grafana, like Azure Monitor metrics and logs, Application Insights, and Kusto, using your existing Azure RBAC and managed identities.

How do you securely connect AI agents to real production telemetry, without standing up yet another piece of infrastructure?

Today, enabling an agent to query systems like Azure Monitor, Application Insights, or Kusto often requires deploying and operating a self‑hosted MCP server, wiring up identity and networking, and maintaining additional runtime infrastructure. That friction slows adoption and expands the security surface area.

Azure Managed Grafana MCP removes that entire layer.

With this release, every Azure Managed Grafana instance now includes a fully managed, remote MCP server that is ready by default.

What is Azure Managed Grafana MCP?

Azure Managed Grafana MCP is a built‑in, managed MCP endpoint that allows AI agents to securely query enterprise telemetry and operational data through Azure Managed Grafana.

Instead of deploying your own MCP server, customers can simply:

Point their agent to the Azure Managed Grafana MCP endpoint
Grant the agent a managed identity
Start querying production data immediately

No containers. No extra infrastructure. No duplicated auth systems.

Azure Managed Grafana MCP is very easy to configure with your existing AMG instance

Because most Azure Managed Grafana customers already connect data sources like Azure Monitor metrics, logs, Kusto, and Application Insights to Azure Managed Grafana, the MCP server can expose that telemetry to AI agents instantly, using the same RBAC and access controls teams already trust.

Why we built this

As we’ve talked with customers experimenting with Foundry and coding agents, a consistent theme has emerged: agents are only as useful as the data they can reason over.

Requiring teams to stand up and operate a separate MCP layer introduces real cost:

Additional infrastructure to deploy and maintain
Custom identity and token handling
Expanded attack surface
Slower experimentation and adoption

This Azure Managed Grafana MCP takes a different approach. Rather than asking customers to build new infrastructure for agents, we leverage infrastructure they already run and trust: Azure Managed Grafana.

This shifts Grafana from being just a visualization layer to something more strategic:

A secure telemetry access plane
An analytical engine for agent reasoning
A bridge between operational data and autonomous action

Core value propositions

Zero infrastructure overhead

Azure Managed Grafana MCP is fully managed and enabled by default:

No self‑hosted MCP servers
No additional networking configuration

Agents connect directly to Azure Managed Grafana and start querying data.

Secure by design

Security is not bolted on, it’s inherited:

Uses existing Azure RBAC
Supports managed identities
Respects current Azure Managed Grafana access controls

There’s no need to duplicate authentication or authorization logic, and the security posture remains consistent with existing observability access patterns.

Immediate enterprise scenarios

By exposing production telemetry through MCP, teams can unlock high‑value agent workflows immediately:

Root cause analysis using Application Insights
Automated operational summaries
Real‑time diagnostics
Cross‑resource telemetry correlation
Structured data access via Kusto

Chatting with an agent using Azure Managed Grafana MCP in Foundry Playground

Chatting with an agent using Azure Managed Grafana MCP

These are scenarios customers already run manually today and this MCP server makes them accessible to agents.

Closing the loop: from insight to action

One of the most powerful aspects of Azure Managed Grafana MCP is what happens when agents have access to both code context and live telemetry.

For example:

An agent queries Application Insights for production errors
Identifies recurring exception patterns
Locates the source code emitting those errors
Generates a fix and submits a pull request

This closes the loop between observability and remediation, something that’s been largely manual until now.

Designing for agents, not just dashboards

Humans and agents consume data very differently.

Humans:

Navigate dashboards sequentially
Are limited by cognitive bandwidth
Correlate issues manually

Agents:

Process large datasets in parallel
Perform iterative drill‑downs without fatigue
Detect statistically significant patterns quickly

Azure Managed Grafana MCP is designed with this in mind. Instead of only exposing raw data, it enables agent‑optimized tools, like aggregated failure views across dozens of Application Insights instances, so agents can reason efficiently at scale. To make it easier for our customers, it is now available as a native tool within Microsoft Foundry, so you can easily connect it to your Foundry Agents.

Azure Managed Grafana MCP as a native Foundry tool

Looking ahead

Azure Managed Grafana MCP is the foundation for a broader vision:

Observability‑driven autonomous agents
Secure enterprise telemetry reasoning
AI systems that detect, diagnose, and act

Over time, this transforms Azure Managed Grafana from dashboard software into a strategic AI integration layer for Azure.

This isn’t just a visualization feature.

It’s an infrastructure shift.

Check out the doc for more information: Configure an Azure Managed Grafana remote MCP server | Microsoft Learn

Introducing Azure Managed Grafana 12

aayodeji — Fri, 13 Mar 2026 16:54:19 GMT

In this release, Azure Managed Grafana makes it easier to tighten access with current-user Entra authentication, speed up Azure Monitor logs exploration, and level up Prometheus and database monitoring experiences.

What’s new in Azure Managed Grafana 12

Use current-user Entra authentication for supported Azure data sources to query with the signed-in user’s permissions.
Analyze Azure Monitor logs faster with a new query builder and improved visualization and Explore experiences.
Explore Prometheus metrics with improved drill-down, prefix and suffix filters, group-by label support, plus OpenTelemetry and native histogram support.
Use updated, pre-built database monitoring dashboards for Azure PostgreSQL, Azure SQL, and SQL Managed Instance (SQL MI).

Advanced authentication: query with current user’s Entra credentials

Current-user Entra authentication is now available in Azure data sources. That means Grafana admins can configure supported data sources to re-use the logged-in user’s credentials when issuing queries. In practice, the signed-in user’s permissions define what data stores they can access, helping teams apply least-privilege access to each user while keeping the option to use Managed Identities and Service Principals in other data sources where that fits best. Supported data sources include:

Azure Monitor
Azure Data Explorer
Azure Monitor Managed Service for Prometheus

Faster log analysis: Click-to-build queries and smoother Explore

If you live in Azure Monitor logs, this update is for you. Improvements to log visualization in the Logs visualization panel and Grafana Explore make it easier to filter and extract meaningful insights from Azure Monitor logs. There’s also a new Azure Monitor logs query builder, so you can create and refine queries with a few clicks instead of writing Kusto Query Language (KQL) by hand. Performance is significantly faster too. Grafana Explore can now query and render up to 30K log records at a time, so you get much faster load times, faster searches, and more responsive navigation through large log volumes.

Prometheus query enhancements: drill down without the query gymnastics

Users new to Prometheus get a smoother path to explore metrics and analyze time series. Metrics drill-down now includes sidebar filters for prefix/suffix so you can quickly narrow metrics by naming conventions, and group-by label support to build more context-rich groupings. This is a true queryless exploration of Azure Managed Prometheus metrics when you’re troubleshooting or just identifying what’s been collected. This release also adds OpenTelemetry & native histogram support, including an OTel mode to automate label-join complexities when querying OTLP metrics.

New database monitoring dashboards

Azure Managed Grafana now includes new versions of pre-built dashboards for monitoring Azure Database for PostgreSQL and Azure SQL Databases (Preview). For teams building on Azure-native databases, these updated dashboards can help you get to a useful baseline faster, so you spend less time wiring panels and more time acting on what the data is telling you.

Getting started

To try Grafana 12, you can create a new Azure Managed Grafana instance with Grafana 12 selected, or upgrade an existing instance from the Azure portal.

From there, consider enabling current-user Entra authentication for supported Azure data sources, test the new Azure Monitor logs query builder in Explore for day-to-day investigations, and take the updated database dashboards for a spin if you run Azure PostgreSQL, Azure SQL, or SQL MI. Check out the doc for more information: Upgrade Azure Managed Grafana to Grafana 12 - Azure Managed Grafana.

Announcing new public preview capabilities in Azure Monitor pipeline

XemaPathak — Thu, 26 Feb 2026 23:27:24 GMT

Azure Monitor pipeline, similar to ETL (Extract, Transform, Load) process, enhances traditional data collection methods. It streamlines data collection from various sources through a unified ingestion pipeline and utilizes a standardized configuration approach that is more efficient and scalable.

As Azure Monitor pipeline is used in more complex and security‑sensitive environments — including on‑premises infrastructure, edge locations, and large Kubernetes clusters — certain patterns and challenges show up consistently.

Based on what we’ve been seeing across these deployments, we’re sharing a few new capabilities now available in public preview. These updates focus on three areas that tend to matter most at scale: secure ingestion, control over where pipeline instances run, and processing data before it lands in Azure Monitor.

Here’s what’s new — and why it matters.

Secure ingestion with TLS and mutual TLS (mTLS)
Pod placement controls for Azure Monitor pipeline
Transformations and Automated Schema Standardization

Secure ingestion with TLS and mutual TLS (mTLS)

Why is this needed?

As telemetry ingestion moves beyond Azure and closer to the edge, security expectations increase. In many environments, plain TCP ingestion is no longer sufficient.

Teams often need:

Encrypted ingestion paths by default
Strong guarantees around who is allowed to send data
A way to integrate with existing PKI and certificate management systems

In regulated or security‑sensitive setups, secure authentication at the ingestion boundary is a baseline requirement — not an optional add‑on.

What does this feature do?

Azure Monitor pipeline now supports TLS and mutual TLS (mTLS) for TCP‑based ingestion endpoints in public preview.

With this support, you can:

Encrypt data in transit using TLS
Enable mutual authentication with mTLS, so both the client and the pipeline endpoint validate each other
Use your own certificates
Enforce security requirements at ingestion time, before data is accepted

This makes it easier to securely ingest data from network devices, appliances, and on‑prem workloads without relying on external proxies or custom gateways. Learn more.

If the player doesn’t load, open the video in a new window: Open video

Pod placement controls for Azure Monitor pipeline

Why is it needed?

As Azure Monitor pipeline scales in Kubernetes environments, default scheduling behavior often isn’t sufficient.

In many deployments, teams need more control to:

Isolate telemetry workloads in multi‑tenant clusters
Run pipelines on high‑capacity nodes for resource‑intensive processing
Prevent port exhaustion by limiting instances per node
Enforce data residency or security zone requirements
Distribute instances across availability zones for better resiliency and resource use

Without explicit placement controls, pipeline instances can end up running in sub‑optimal locations, leading to performance and operational issues.

What does this feature do?

With the new executionPlacement configuration (public preview), Azure Monitor pipeline gives you direct control over how pipeline instances are scheduled.

Using this feature, you can:

Target specific nodes using labels (for example, by team, zone, or node capability)
Control how instances are distributed across nodes
Enforce strict isolation by allowing only one instance per node
Apply placement rules per pipeline group, without impacting other workloads

These rules are validated and enforced at deployment time. If the cluster can’t satisfy the placement requirements, the pipeline won’t deploy — making failures clear and predictable.

This gives you better control over performance, isolation, and cluster utilization as you scale. Learn more.

Transformations and Automated Schema Standardization

Why is this needed?

Telemetry data is often high‑volume, noisy, and inconsistent across sources. In many deployments, ingesting everything as‑is and cleaning it up later isn’t practical or cost‑effective.

There’s a growing need to:

Filter or reduce data before ingestion
Normalize formats across different sources
Route data directly into standard tables without additional processing

What does this feature do?

Azure Monitor pipeline data transformations, already in public preview, let you process data before it’s ingested.

With transformations, you can:

Filter, aggregate, or reshape incoming data
Convert raw syslog or CEF messages into standardized schemas
Choose sample KQL templates to perform transformations instead of manually writing KQL queries
Route data directly into built‑in Azure tables
Reduce ingestion volume while keeping the data that matters

Check out the recent blog about the transformations preview, or you can learn more here.

Getting started

All of these capabilities are available today in public preview as part of Azure Monitor pipeline.

If you’re already using the pipeline, you can start experimenting with secure ingestion, pod placement, and transformations right away. As always, feedback is welcome as we continue to refine these features on the path to general availability.

Public Preview: Azure Monitor pipeline transformations

susaraswat4 — Thu, 26 Feb 2026 23:25:47 GMT

Overview

The Azure Monitor pipeline extends the data collection capabilities of Azure Monitor to edge and multi-cloud environments. It enables at-scale data collection (data collection over 100k EPS), and routing of telemetry data before it's sent to the cloud. The pipeline can cache data locally and sync with the cloud when connectivity is restored and route telemetry to Azure Monitor in cases of intermittent connectivity. Learn more about this here - Configure Azure Monitor pipeline - Azure Monitor | Microsoft Learn

Why transformations matter

Lower Costs: Filter and aggregate before ingestion to reduce ingestion volume and in turn lower ingestion costs

Better Analytics: Standardized schemas mean faster queries and cleaner dashboards.

Future-Proof: Built-in schema validation prevents surprises during deployment.

Azure Monitor pipeline solves the challenges of high ingestion costs and complex analytics by enabling transformations before ingestion, so your data is clean, structured, and optimized before it even hits your Log Analytics Workspace.

Check out a quick demo here -

If the player doesn’t load, open the video in a new window: Open video

Key features in public preview

1. Schema change detection

One of the most exciting additions is schema validation for Syslog and CEF :

Integrated into the “Check KQL Syntax” button in the Strato UI.

Detects if your transformation introduces schema changes that break compatibility with standard tables.

Provides actionable guidance:

- Option 1: Remove schema-changing transformations like aggregations.

- Option 2: Send data to a custom tables that support custom schemas.

This ensures your pipeline remains robust and compliant with analytics requirements.

For example, in the picture below, extending to new columns that don't match the schema of the syslog table throws an error during validation and asks the user to send to a custom table or remove the transformations.

While in the case of the example below, filtering does not modify the schema of the data at all and so no validation error is thrown, and the user is able to send it to a standard table directly.

2. Pre-built KQL templates

Apply ready-to-use templates for common transformations.

Save time and minimize errors when writing queries.

3. Automatic schema standardization for syslog and CEF

Automatically schematize CEF and syslog data to fit standard tables without any added transformations to convert raw data to syslog/CEF from the user.

4. Advanced filtering

Drop unwanted events based on attributes like:

- Syslog: Facility, ProcessName, SeverityLevel.

- CEF: DeviceVendor, DestinationPort.

Reduce noise and optimize ingestion costs.

5. Aggregation for high-volume logs

Group events by key fields (e.g., DestinationIP, DeviceVendor) into 1-minute intervals.

Summarize high-frequency logs for actionable insights.

6. Drop unnecessary fields

Remove redundant columns to streamline data and reduce storage overhead.

Supported KQL sunctions

1. Aggregation 

summarize (by), sum, max, min, avg, count, bin

2. Filtering 

where, contains, has, in, and, or, equality (==, !=), comparison (>, >=, <, <=)

3. Schematization  

extend, project, project-away, project-rename, project-keep, iif, case, coalesce, parse_json

4. Variables for Expressions or Functions 

5. Other Functions 

String: strlen, replace_string, substring, strcat, strcat_delim, extract 
Conversion: tostring, toint, tobool, tofloat, tolong, toreal, todouble, todatetime, totimespan

Get started today

Head to the Azure Portal and explore the new Azure Monitor pipeline transformations UI. Apply templates, validate your KQL, and experience the power of Azure Monitor pipeline transformations. Find more information on the public docs here - Configure Azure Monitor pipeline transformations - Azure Monitor | Microsoft Learn

Accelerating SCOM to Azure Monitor Migrations with Automated Analysis and ARM Template Generation

OREN_SALZBERG — Wed, 11 Feb 2026 08:59:53 GMT

Accelerating SCOM to Azure Monitor Migrations with Automated Analysis and ARM Template Generation

Azure Monitor has become the foundation for modern, cloud-scale monitoring on Azure. Built to handle massive volumes of telemetry across infrastructure, applications, and services, it provides a unified platform for metrics, logs, alerts, dashboards, and automation. As organizations continue to modernize their environments, Azure Monitor is increasingly the target state for enterprise monitoring strategies.

With Azure Monitor increasingly becoming the destination platform, many organizations face a familiar challenge: migrating from System Center Operations Manager (SCOM). While both platforms serve the same fundamental purpose—keeping your infrastructure healthy and alerting you to problems—the migration path isn’t always straightforward.

SCOM Management Packs contain years of accumulated monitoring logic: performance thresholds, event correlation rules, service discoveries, and custom scripts. Translating all of this into Azure Monitor’s paradigm of Log Analytics queries, alert rules, and Data Collection Rules can be a significant undertaking.

To help with this challenge, members of the community have built and shared a tool that automates much of the analysis and artifact generation.

The community-driven SCOM to Azure Monitor Migration Tool accepts Management Pack XML files and produces several outputs designed to accelerate migration planning and execution.

The tool parses the Management Pack structure and identifies all monitors, rules, discoveries, and classes. Each component is analyzed for migration complexity: some translate directly to Azure Monitor equivalents, while others require custom implementation or may not have a direct equivalent.

Results are organized into two clear categories:

Auto-Migrated Components – Covered by the generated templates and ready for deployment
Requires Manual Migration – Components that need custom implementation or review

Instead of manually authoring Azure Resource Manager templates, the tool generates deployable infrastructure-as-code artifacts, including:

Scheduled Query Alert rules mapped from SCOM monitors and rules
Data Collection Rules for performance counters and Windows Events
Custom Log DCRs for collecting script-generated log files
Action Groups for notification routing
Log Analytics workspace configuration (for new environments)

For streamlined deployment, the tool offers a combined ARM template that deploys all resources in a single operation:

Log Analytics workspace (create new or connect to an existing workspace)
Action Groups with email notification
All alert rules
Data Collection Rules
Monitoring Workbook

One download, one deployment command — with configurable parameters for workspace settings, notification recipients, and custom log paths.

The tool generates an Azure Monitor Workbook dashboard tailored to the Management Pack, including:

Performance counter trends over time
Event monitoring by severity with drill-down tables
Service health overview (stopped services)
Active alerts summary from Azure Resource Graph

This provides immediate operational visibility once the monitoring configuration is deployed.

Each migrated component includes the Kusto Query Language (KQL) equivalent of the original SCOM monitoring logic. These queries can be used as-is or refined to match environment-specific requirements.

The workflow is designed to reduce the manual effort involved in migration planning:

Export your Management Pack XML from SCOM
Upload it to the tool
Review the analysis — components are separated into auto-migrated and requires manual work
Download the All-in-One ARM template (or individual templates)
Customize parameters such as workspace name and action group recipients
Deploy to your Azure subscription

For a typical Management Pack, such as Windows Server Active Directory monitoring, you may see 120+ components that can be migrated directly, with an additional 15–20 components requiring manual review due to complex script logic or SCOM-specific functionality.

The tool handles straightforward translations well:

Performance threshold monitors become metric alerts or log-based alerts
Windows Event collection rules become Data Collection Rule configurations
Service monitors become scheduled query alerts against Heartbeat or Event tables

Components that typically require manual attention:

Complex PowerShell or VBScript probe actions
Monitors that depend on SCOM-specific data sources
Correlation rules spanning multiple data sources
Custom workflows with proprietary logic

The tool clearly identifies which category each component falls into, allowing teams to plan their migration effort with confidence.

A Note on Validation

This is a community tool, not an officially supported Microsoft product. Generated artifacts should always be reviewed and tested in a non-production environment before deployment.

Every environment is different, and the tool makes reasonable assumptions that may require adjustment. Even so, starting with structured ARM templates and working KQL queries can significantly reduce time to deployment.

Try It Out

The tool is available at https://tinyurl.com/Scom2Azure.Upload a Management Pack, review the analysis, and see what your migration path looks like.

Announcing Application Insights SDK 3.x for .NET

MattMc — Tue, 10 Feb 2026 00:25:02 GMT

Microsoft remains committed to making OpenTelemetry the foundation of modern observability on Azure. Today, we’re excited to take the next step on that journey with a major release of the Application Insights SDK 3.x for .NET.

Migrate to OpenTelemetry with a Major Version Bump

With Application Insights SDK 3.x, developers can migrate to OpenTelemetry-based instrumentation with dramatically less effort. Until now, migrating from classic Application Insights SDK to the Azure Monitor OpenTelemetry Distro required a clean install and code updates.

With this release, most customers can adopt OpenTelemetry simply by upgrading their SDK version. The new SDK automatically routes your classic Application Insights Track* APIs calls through a new mapping layer that emits OpenTelemetry signals under the hood.

Why This Matters

By upgrading, you gain:

✔ Vendor‑neutral OpenTelemetry APIs going forward
You can immediately begin writing new code using OpenTelemetry APIs, ensuring future portability and alignment with industry standards.

✔ Access to the full OpenTelemetry ecosystem
You can now easily plug in community instrumentation libraries and exporters. For example, collecting Redis Cache dependency data—previously not supported with Application Insights 2.x—becomes straightforward.

✔ Multi‑exporter support
Export to Azure Monitor and another system (e.g., a SIEM or backend of your choice) simultaneously if your scenario requires it.

What Still Requires Attention: Initializers and Processors

One area where automatic migration is not possible is telemetry processors and telemetry initializers. These Application Insights extensibility points were extremely flexible, allowing custom property injection, filtering, or deletion logic.

OpenTelemetry supports similar behavior, but through more structured concepts such as span processors. See here for a full list of breaking changes.

On a positive note, these OpenTelemetry components generally deliver better performance and clearer behavior. Our documentation assists with migration, and we plan to release an MCP with guardrails to assist LLM in accurate coding.

Keeping the essence of Azure Monitor Application Insights

While OpenTelemetry encourages the use of the OpenTelemetry-Collector, we remain committed to preserving the simplicity that customers love about Azure Monitor Application Insights. The Azure Monitor OpenTelemetry Distro is all that’s required to get started. It’s just a single NuGet package and you configure it with a Connection String. Telemetry flows in minutes.

No Collector is required unless you explicitly want one. We are able to achieve this with extensive built‑in sampling to manage cost and a trace‑preservation algorithm, so you see complete traces. This keeps the “just works” spirit of Azure Monitor Application Insights intact, while aligning with OpenTelemetry standards.

Feedback

If you encounter issues during the upgrade, please open a support ticket—we want the migration to be smooth. If you’d like to share feedback or engage directly with the product team, email us at otel@microsoft.com. This is not an official support channel, but we read every email and appreciate hearing feedback directly from you!

Observability for the Age of Generative AI

Hong Gao — Thu, 27 Nov 2025 01:26:39 GMT

Every generation of computing brings new challenges in how we monitor and trust our systems.

With the rise of Generative AI, applications are no longer static code—they’re living systems that plan, reason, call tools, and make choices dynamically.

Traditional observability, built for servers and microservices, simply can’t tell you when an AI agent is correct, safe, or cost-efficient.

We’re reimagining observability for this new world.

At Ignite, we introduced the next wave of Azure Monitor and AI Foundry integration—purpose-built for GenAI apps and agents.

End-to-End GenAI Observability Across the AI Stack

Customers can see not just whether their systems are up or fast, but also whether their agent responses are accurate.

Azure Monitor, in partnership with Foundry, unifies agent telemetry with infrastructure, application, network, and hardware signals—creating a true end-to-end view that spans AI agents, the services they call, and the compute they run on.

New capabilities include:

Agent Overview Dashboard in Grafana and Azure – Gain a unified view of one or more GenAI agents, including success rate, grounding quality, safety violations, latency, and cost per outcome. Customize dashboards in Grafana or Azure Monitor Workbooks to detect regressions instantly after a model or prompt change—and understand how those changes affect user experience and spend.

AI-Tailored Trace View – Follow every AI decision as a readable story: plan → reasoning → tool calls → guardrail checks. Identify slow or unsafe steps in seconds, without sifting through thousands of spans.

AI-Aware Trace Search by Attributes – Search, sort, and filter across millions of runs using GenAI-specific attributes like model ID, grounding score, or cost. Find the “needle” in your GenAI haystack in a single query.

Foundry Low-Code Agent Monitoring – Agents created through Foundry’s visual, low-code interface are now automatically observable. Without writing a single line of code, you can track reliability, safety, and cost metrics from day one.

Full-Stack Visibility Across the AI Stack – All evaluations, traces, and red-teaming results are now published to Azure Monitor, where agent signals correlate seamlessly with infrastructure KPIs and application telemetry to deliver a unified operational view.

Check out our get started documentation. 

Powered by OpenTelemetry Innovation

This work builds directly on the new OpenTelemetry extensions announced in our recent Azure AI Foundry blog post.

Microsoft is helping define the OpenTelemetry agent specification, extending it to capture multi-agent orchestration traces, LLM reasoning context, and evaluation signals—enabling interoperability across Azure Monitor, AI Foundry, and partner tools such as Datadog, Arize, and Weights & Biases.

By building on open standards, customers gain consistent visibility across multi-cloud and hybrid AI environments—without vendor lock-in.

Built for Enterprise Scale and Trust

With open standards and deep integration between Azure Monitor and AI Foundry, organizations can now apply the same discipline they use for traditional applications to their GenAI workloads, complete with compliance, cost governance, and quality assurance.

GenAI is redefining what it means to operate software.

With these innovations, Microsoft is giving customers the visibility, control, and confidence to operate AI responsibly, at enterprise scale.

Announcing public preview of query-based metric alerts in Azure Monitor

yairgil — Sun, 23 Nov 2025 18:55:48 GMT

Azure Monitor metric alerts are now more powerful than ever

Azure Monitor metric alerts now support all Azure metrics - including platform, Prometheus, and custom metrics - giving you complete coverage for your monitoring needs.
In addition, metric alerts now offer powerful query capabilities with PromQL, enabling complex logic across multiple metrics and resources. This makes it easier to detect patterns, correlate signals, and customize alerts for modern workloads like Kubernetes clusters, VMs, and custom applications.

Key Benefits

Full metrics coverage: metric alerts now support alerting on any Azure metrics including platform metrics, Prometheus metrics and custom metrics.
PromQL-Powered Conditions: Use PromQL to select, aggregate, and transform metrics for advanced alerting scenarios.
Powerful event detection: Query-based alert rules can now detect intricate patterns across multiple timeseries based on metric change ratio, complex aggregations, or comparison between different metrics and timeseries. You can also analyze metrics across different time windows to identify change in metric behavior over time.
Flexible Scoping: For query-based alert rules, choose between resource-centric alerts for granular RBAC or workspace-centric alerts for cross-resource visibility.
Alerting at scale: Query-based alert rules allow monitoring metrics from multiple resources within a subscription or a resource group, using a single rule.
Managed Identity Support: Securely authorize queries using Azure Managed Identity, ensuring compliance and reducing credential management overhead.
Customizable Notifications: Add dynamic custom properties and custom email subjects for faster triage and context-rich alerting.
Reuse community alerts: Easily import and re-use PromQL alert queries from the open-source community or from other Prometheus-based monitoring systems.

Supported metrics

At this time, query-based metric alerts support any metrics ingested into Azure Monitor Workspace (AMW). This currently includes:

Metrics collected by Azure Monitor managed service for Prometheus, from Azure Kubernetes Services clusters (AKS) or from other sources.
Virtual machine OpenTelemetry (OTel) Guest OS Metrics
Other OTel custom metrics collected into Azure Monitor.

You can still create threshold-based metric alerts as before on Azure platform metrics. Query-based alerts on platform metrics will be added in future releases.

Comparison: Query-based metric alerts vs. Prometheus rule groups alerts

Query-based metric alerts serve as an alternative to alerts defined in Prometheus rule groups. Both options remain viable and execute the same PromQL-based alerting logic.

However, metric alerts are natively integrated with Azure Monitor, aligning seamlessly with other Azure alert types. They now support all your metric alerting needs within the same rule type. They also offer richer functionality and greater flexibility, making them a strong choice for teams looking for consistency across Azure monitoring solutions. See the table below for detailed comparison of the two alternatives.

Stay tuned - additional enhancements to metric alerts are coming in future releases!

Feature	Azure Prometheus rule groups	Query-based metric alerts
Alert rule management	Part of a rule group resource	Independent Azure resource
Supported metrics	Metrics in AMW (Managed Prometheus)	Metrics in AMW (Managed Prometheus, OTel metrics)
Condition logic	PromQL-based query	PromQL-based query
Aggregation & transformation	Full PromQL support	Full PromQL support
Scope	Workspace-wide	Resource-centric or workspace-wide
Alerting at scale	Not supported	Subscription level, Resource-group level
Cross-resource conditions	Supported	Supported
RBAC granularity	Workspace level	Resource or workspace level
Managed identity support	Not supported	Supported
Notification customization	Supported - Prometheus labels and annotations	Advanced - dynamic custom properties, custom email subject

Getting Started

If you have an Azure Monitor workspace containing Prometheus or OpenTelemetry metrics, you can create query-based metric alert rules today. Rules can be created and managed using the Azure Portal, ARM templates, or Azure REST API. For details, visit Azure Monitor documentation.

Generally Available - Azure Monitor Private Link Scope (AMPLS) Scale Limits Increased by 10x!

Mahesh_Sundaram — Thu, 20 Nov 2025 23:36:06 GMT

Introduction

We are excited to announce the General Availability (GA) of Azure Monitor Private Link Scope (AMPLS) scale limit increase, delivering 10x scalability improvements compared to previous limits. This enhancement empowers customers to securely connect more Azure Monitor resources via Private Link, ensuring network isolation, compliance, and Zero Trust alignment for large-scale environments.

What is Azure Monitor Private Link Scope (AMPLS)?

Azure Monitor Private Link Scope (AMPLS) is a feature that allows you to securely connect Azure Monitor resources to your virtual network using private endpoints. This ensures that your monitoring data is accessed only through authorized private networks, preventing data exfiltration and keeping all traffic inside the Azure backbone network.

AMPLS – Scale Limits Increased by 10x in Public Cloud & Sovereign Cloud (Fairfax/Mooncake) - Regions

In a groundbreaking development, we are excited to share that the scale limits for Azure Monitor Private Link Scope (AMPLS) have been significantly increased by tenfold (10x) in Public & Sovereign Cloud regions as part of the General Availability! This substantial enhancement empowers our customers to manage their resources more efficiently and securely with private links using AMPLS, ensuring that workload logs are routed via the Microsoft backbone network.

AMPLS - Scale Limit Increase - End-to-End Monitoring Telemetry flow

What’s New?

10x Scale Increase
- Connect up to 3,000 Log Analytics workspaces per AMPLS (previously 300)
- Connect up to 10,000 Application Insights components per AMPLS (previously 1,000)
20x Resource Connectivity
- Each Azure Monitor resource can now connect to 100 AMPLS resources (previously 5)
Enhanced UX/UI
- Redesigned AMPLS interface supports loading 13,000+ resources with pagination for smooth navigation
Private Endpoint Support
- Each AMPLS object can connect to 10 private endpoints, ensuring secure telemetry flows

Why It Matters

Top Azure Strategic 500 customers, including major Telecom service providers and Banking & Financial Services organizations, have noted that previous AMPLS limits did not adequately support their increasing requirements. The demand for private links has grown 3–5 times over existing capacity, affecting both network isolation and integration of essential workloads. This General Availability release resolves these issues, providing centralized monitoring at scale while maintaining robust security and performance.

Customer Stories

Our solution now enables customers to scale their Azure Monitor resources significantly, ensuring seamless network configurations and enhanced performance.

Customer B - Case Study: Leading Banking & Financial Services Customer

Challenge:

The Banking Customer faced complexity in delivering personalized insights due to intricate workflows and content systems. They needed a solution that could scale securely while maintaining compliance and performance for business-critical applications.

Solution:

The Banking Customer has implemented Microsoft Private Links Services (AMPLS) to enhance the security and performance of financial models for smart finance assistants, leading to greater efficiency and improved client engagement. To ensure secure telemetry flow and compliance, the banking customer implemented Azure Monitor with Private Link Scope (AMPLS) and leveraged the AMPLS Scale Limit Increase feature.

Business Impact:

Strengthened security posture aligned with Zero Trust principles
Improved operational efficiency for monitoring and reporting
Delivered a future-ready architecture that scales with evolving compliance and performance demands

Customer B - Case Study: Leading Telecom Service Provider - Scaling Secure Monitoring with AMPLS

Architecture:

A Leading Telecom Service Provider employs a highly micro-segmented design where each DevOps team operates in its own workspace to maximize security and isolation.

Challenge:

While this design strengthens security, it introduces complexity for large-scale monitoring and reporting due to physical and logical limitations on Azure Monitor Private Link Scope (AMPLS). Previous scale limits made it difficult to centralize telemetry without compromising isolation.

Solution:

The AMPLS Scale Limit Increase feature enabled the Telecom Service Provider to expand Azure Monitor resources significantly. Monitoring traffic now routes through Microsoft’s backbone network, reducing data exfiltration risks and supporting Zero Trust principles.

Impact & Benefits

Scalability: Supports up to 3,000 Log Analytics workspaces and 10,000 Application Insights components per AMPLS (10× increase).
Efficiency: Each Azure Monitor resource can now connect to 100 AMPLS resources (20× increase).
Security: Private connectivity via Microsoft backbone mitigates data exfiltration risks.
Operational Excellence: Simplifies configuration for 13K+ Azure Monitor resources, reducing overhead for DevOps teams.

Customer Benefits & Results

Our solution significantly enhances customers’ ability to manage Azure Monitor resources securely and at scale using Azure Monitor Private Link Scope (AMPLS).

Key Benefits

Massive Scale Increase
- 3,000 Log Analytics workspaces (previously 300)
- 10,000 Application Insights components (previously 1,000)
- Each AMPLS object can now connect to:
- Azure Monitor resources can now connect with up to 100 AMPLS resources (20× increase).
Broader Resource Support - Supported resource types include:
- Data Collection Endpoints (DCE)
- Log Analytics Workspaces (LA WS)
- Application Insights components (AI)
Improved UX/UI
- Redesigned AMPLS interface supports loading 13,000+ Azure Monitor resources with pagination for smooth navigation.
Private Endpoint Connectivity
- Each AMPLS object can connect to 10 private endpoints, ensuring secure telemetry flows.

Resources:

Explore the new capabilities of Azure Monitor Private Link Scope (AMPLS) and see how it can transform your network isolation and resource management. Visit our Azure Monitor Private Link Scope (AMPLS) documentation page for more details and start leveraging these enhancements today!

For detailed information on configuring Azure Monitor private link scope and azure monitor resources, please refer to the following link:

General Availability: Granular RBAC in Azure Monitor Logs

Ron Frenkel — Wed, 19 Nov 2025 09:55:04 GMT

We’re excited to announce the general availability of Granular Role-Based Access Control (RBAC) in Azure Monitor Logs!

This capability enables you to set fine-grained data access control at the row level, giving you more flexibility and security when managing log data.

Back in May 2025, we introduced this feature in public preview. Today, it’s fully available and ready for production use

What is Granular RBAC?

Organizations often need to segregate and control access to data without trading off the benefits of a centralized logging platform. Granular RBAC builds on existing Azure RBAC capabilities for workspace and table-level access, allowing you to:

Apply least privilege access at any level, workspace, table, or row level security.
Maintain all your data in a single Log Analytics workspace.
Separate data plane and control plane access using Azure Attribute-Based Access Control (ABAC) as part of your RBAC role assignments.

With Granular RBAC, you can filter which data each user can view or query based on conditions you define such as organizational roles, geographic regions, or data sensitivity levels.

What’s New?

Broad Availability: Granular RBAC is now supported in Azure Public Cloud, Azure Government (GCC), and Azure China.
New Built-in Role: The Log Analytics Data Reader role now fully supports Granular RBAC for an out-of-the-box experience. Learn more

Get Started

Learn more about Granular RBAC and how to set it up in Azure Monitor Logs

We hope you enjoy this new addition to Azure Monitor Log Analytics.

Announcing General Availability: Azure Monitor dashboards with Grafana

KayodePrince — Tue, 18 Nov 2025 16:56:24 GMT

Continuing our commitment to open-source solutions, we are announcing the general availability of Azure Monitor dashboards with Grafana. This service offers a powerful solution for cloud-native monitoring and visualizing all your Azure data.

Dashboards with Grafana enable you to create and edit Grafana dashboards directly in the Azure portal without additional cost and less administrative overhead compared to self-hosting Grafana or using managed Grafana services. Built-in Grafana controls and components allow you to apply a rich set of visualization panels and client-side transformations to Azure monitoring data to create custom dashboards.

Start quickly with pre-built and community dashboards

Dozens of pre-built Grafana dashboards for Azure Kubernetes Services, Application Insights, Storage Accounts, Cosmos DB, Azure PostgreSQL, OpenTelemetry metrics and dozens of other Azure resources are included and enabled by default. Additionally, you can import dashboards from thousands of publicly available Grafana community and open-source dashboards for the supported data sources: Prometheus, Azure Monitor (metrics, logs, traces, Azure Resource Graph), and Azure Data Explorer.

Streamline monitoring with open-source compatibility and Azure enterprise capabilities

Azure Monitor dashboards with Grafana are fully compatible with open-source Grafana dashboards and are portable across any Grafana instances regardless of where they are hosted. Furthermore, dashboards are native Azure resources supporting Azure RBAC to assign permissions, and automation via ARM and Bicep templates.

Import, edit and create dashboards in 30+ Azure regions
Choose from any language in the Azure Portal for your Grafana user interface
Manage dashboard content as part of the ARM resource
Automatically generate ARM templates to automate deployment and manage dashboards

Take advantage of Grafana Explore and New Dashboards

Leverage Grafana Explore to quickly create ad-hoc queries without modifying dashboards and add queries and visualizations to new or existing dashboards

New out of the box dashboards for additional Azure resources:

Additional Azure Kubernetes Service support including AKS Automatic and AKS Arc connected clusters
Azure Container Apps monitoring dashboards
Microsoft Foundry monitoring dashboards
Azure Monitor Application Insights dashboards
- OpenTelemetry metrics
- Microsoft Agent Framework
High Performance Computing dashboards with dedicated GPU monitoring

When to step up to Azure Managed Grafana?

If you store your telemetry data in Azure, Dashboards with Grafana in the Azure portal is a great way to get started with Grafana. If you have additional 3rd-party data sources, or need full enterprise capabilities in Grafana, you can choose to upgrade to Azure Managed Grafana, a fully managed hosted service for the Grafana Enterprise software.

See a detailed solution comparison of Dashboards with Grafana and Azure Managed Grafana here.

Get started with Azure Monitor dashboards with Grafana today.

Simplify Application Monitoring for AKS with Azure Monitor (Public Preview)

austonli — Tue, 18 Nov 2025 16:15:50 GMT

As cloud-native workloads scale, customers increasingly expect application and infrastructure observability to be unified, automated, and devops-friendly. Azure Monitor is advancing this vision with Application Monitoring for Azure Kubernetes Service (AKS). With seamless onboarding and troubleshooting experiences in the Azure Portal, now in Public Preview.

This new capability brings first-class OpenTelemetry support, seamless onboarding from the AKS cluster blade, and auto-instrumentation and auto-configuration options that make it easier than ever to collect application performance data into Azure Monitor and Application Insights—without modifying application code or maintaining custom agents. Enable application monitoring for your AKS deployed apps directly from the Azure Portal in two steps:

1. Enable application monitoring for the AKS cluster in Monitor Settings

2. Choose the namespaces for application monitoring and configure namespace-wide onboarding to route application signals to an App Insights resource. Optionally, leverage Custom Resource Definitions (CRDs) for more granular enablement and per-deployment onboarding.

Feature Highlights

Auto-instrumentation

Auto-instrument Java and NodeJS applications without code changes. This approach instruments workloads with the AzureMonitor OpenTelemetry distro and routes telemetry to Application Insights. Now available in both CLI and Azure portal for addon enablement and namespace configuration.

Unified Monitoring and Troubleshooting

Switch seamlessly between infrastructure and application layers with improved navigation between Container Insights and Application Insights, curated OpenTelemetry workbooks, and Azure-curated Grafana dashboards.

When looking into your deployment controllers from Container Insights, you can also see the application performance metrics alongside to identify problematic requests or failures. From there, you can seamlessly transition over to your Application Insights to get a more detailed diagnosis.

View your application performance next to your infrastructure metrics in Container Insights

Full-Stack Dashboards with Grafana

This new application monitoring capability becomes even more powerful when paired with Dashboards with Grafana for Azure Monitor. With curated, Azure-hosted Grafana dashboards built specifically for Application Insights and OpenTelemetry data, teams can extend their AKS application monitoring experience with rich, full-stack visualizations tailored for cloud-native workloads.

Application monitoring dashboards available through Dashboards with Grafana

These dashboards allow you to:

Bring application traces, requests, dependencies, and exception data from Application Insights into Grafana dashboards optimized for app-centric troubleshooting.
Correlate application performance with AKS infrastructure metrics, including node, pod, and container health, to rapidly identify cross-layer issues.
Visualize OpenTelemetry signals flowing through Azure Monitor in a unified, standards-based format without needing to build dashboards from scratch.
Customize and extend dashboards with your own OTel metrics or additional Application Insights dimensions for deeper app performance analytics.

By combining Application Monitoring for AKS with Dashboards for Grafana, developers and operators gain a complete, end-to-end view of application behavior, making it faster and easier to diagnose issues, validate deployments, and understand the health of microservices running on AKS.

Call to Action

Start simplifying application observability today with Azure Monitor for AKS.
Unify your metrics, logs, and traces in a single monitoring experience powered by OpenTelemetry and Azure Monitor.

Explore the documentation and get started:
https://learn.microsoft.com/azure/azure-monitor/app/kubernetes-codeless

Learn more about our new features for OpenTelemetry in Azure Monitor:

https://aka.ms/igniteotelblog

Troubleshoot with OTLP signals in Azure Monitor (Limited Public Preview)

SoubhagyaDash — Tue, 18 Nov 2025 16:09:25 GMT

As organizations increasingly rely on distributed cloud-native applications, the need for comprehensive standards-based observability has never been greater. OpenTelemetry (OTel) has emerged as the industry standard for collecting and transmitting telemetry data, enabling unified monitoring across diverse platforms and services. Microsoft is among the top contributors to OpenTelemetry. Azure Monitor is expanding its support for the OTel standard with this preview, empowering developers and operations teams to seamlessly capture, analyze, and act on critical signals from their applications and infrastructure.

With this limited preview (sign-up here), regardless of where your applications are running, you can channel the OpenTelemetry Protocol (OTLP) logs, metrics and traces to Azure Monitor directly. On Azure compute platforms, we have simpler collection orchestration that also unifies application and infrastructure telemetry collection with the Azure Monitor collection offerings for VM/VMSS or AKS.

On Azure VMs/VMSS (or any Azure Arc supported compute), you can use the Azure Monitor Agent (AMA) that you are already using to collect infrastructure logs.
On AKS, the Azure Monitor add-ons that orchestrate Container Insights and managed Prometheus, will also auto configure the collection of OTLP signals from your applications (or auto-instrument with Azure Monitor OTel Distro for supported languages).

On these platforms or anywhere else, you can choose to use OpenTelemetry Collector, and channel the OTLP signals from your OTel SDK instrumented application directly to Azure Monitor cloud ingestion endpoints.

Collect OTLP signals easily with ambient agent/add-on from Azure computes, or use your own OTel Collector to channel OTLP signals into Azure Monitor for rich troubleshooting experiences

OTLP metrics will be stored in Azure Monitor Workspace, a Prometheus metrics store. Logs and traces will be stored in Azure Monitor Log Analytics Workspace in an OTel semantic conventions-based schema. Application Insights experiences will light up, enabling all distributed tracing and troubleshooting experiences powered by Azure Monitor, as well as out of the box Dashboards with Grafana from the community.

With this preview, we are also extending the support for auto-instrumentation of applications on AKS to .NET and Python applications and introducing OTLP metrics collection from all auto-instrumented applications (Java/Node/.NET/Python).

Sign-up for the preview here: https://aka.ms/azuremonitorotelpreview.

Azure Copilot observability agent: Intelligent Investigations Across Your Azure Stack

EfratNauerman — Tue, 18 Nov 2025 16:02:34 GMT

Cloud operations require more than reactive troubleshooting; they demand intelligent observability that scales across resources and interfaces and provides actionable insights when services are not operating as expected. We are introducing the Azure Copilot observability agent that materializes this promise. Azure Copilot observability agent extends and builds on top of what was previously known was the Azure Monitor investigation capability and introduces a slick experience, combining the power of agentic investigations with expanded capabilities for deeper visibility and faster resolution.

Smarter insights, faster recovery, deeper visibility across your Azure stack.

What it is

The Azure Copilot observability agent works within your Azure workflows to make troubleshooting faster and smarter. It helps you:

Automatically isolate problems in complex applications across the stack
Detect and correlate anomalies from metrics, logs and other observability signals to help identify cause of an issue
Correlate data from multiple sources for full context.
Generate actionable findings and next steps described in clear human language.
Preserve results for collaboration and tracking.

Integrated with alerts, the Azure portal, and Azure Copilot (gated preview), the Azure Copilot observability agent ensures investigations are seamless and actionable.

How it works

When you get an alert and need to investigate it quickly and take action, simply click on the ‘Investigate’ button. Next, you’ll see a list of AI-generated findings to select from. Each finding suggests possible causes behind what went wrong and offers a starting point for troubleshooting.

In order to get a better understanding of the summary, you can easily access the supporting Data.

Behind the scenes, the observability agent uses the power of AI, Machine learning models for anomaly detection and correlation, and large language models (LLMs) to deliver these insights.

Expanded intelligence for critical resources

The Azure Copilot observability agent now delivers intelligent, AI-driven investigations across your Azure stack, from application services down to the underlying infrastructure. It automatically scopes from the resource to dependent components and infrastructure layers, correlating metrics, logs, and health signals for deeper visibility and faster root cause analysis. This includes support across a customer’s application services and critical Azure resources such as Virtual Machines (VM), Azure Kubernetes Service (AKS) clusters, and more, providing true full-stack coverage for complex environments.

For these environments, investigations leverage multiple analysis types to deliver deeper insights:

Metric analysis - detect abnormal CPU, memory, or network utilization patterns in VMs and AKS nodes, helping identify resource pressure before it impacts workloads.
Recent alerts correlation - when a spike in AKS pod restarts occurs, the observability agent correlates with recent alerts to highlight cascading issues across cluster components.
Resource health checks - surface health signals for VMs and AKS nodes alongside anomaly findings, enabling operators to validate whether infrastructure degradation is contributing to application instability.
Resource diagnostics tools integration - findings are automatically connected to built-in Azure diagnostics for quick validation and remediation steps without leaving the investigation workflow
Log-based metric analysis - for AKS and VM environments, enrich metric anomaly detection with contextual tags and data derived from logs, enabling more precise root cause identification.

Extended regional availability

The Azure Copilot observability agent is now supported in most Azure regions , so you can leverage its capabilities wherever your workloads run

Copilot support

With Copilot, you can instantly interact with your alerts in a natural way. Just ask questions like ‘Show me my critical alerts’ or ‘Which alerts need my attention?’ Copilot will surface a clear list of alerts for you. From there, simply click an alert to view its details and access the Investigate button -your gateway to the Azure Copilot observability agent. With one click, you can dive deeper, uncover potential root causes, and get actionable insights to resolve issues faster.

Looking ahead

The Azure Copilot observability agent is evolving toward a broader role in your observability strategy. While today it focuses on investigations, we have an exciting roadmap to make investigations even smarter and more actionable. Future releases will also expand into advanced scenarios, such as correlating issues and managing monitoring configurations without adding complexity.

Start using the Azure Copilot observability agent today

Available in preview, the Azure Copilot observability agent is integrated into your existing Azure workflows. Access it from alerts, the Azure portal, or Azure Copilot (gated preview) and experience a smarter way to resolve issues.

Learn more: documentation for full details on capabilities and setup.

We’re committed to evolving the observability agent based on your feedback. Share your thoughts via azmoninvestigation@microsoft.com or through the Give Feedback form in the experience.

Don’t Miss What’s Next

Ignite Session: Unlock cloud-scale observability and optimization with Azure
December Webinar: Updates, best practices, and live Q&A, 👉 to secure your spot!
NEW Deep Preview! In parallel with this preview, we are starting a preview of new exciting investigation capabilities, enabling deeper and more precise investigation insights. We have enabled Azure Copilot observability agent with deep agentic reasoning, also enabling dialog with the developer in natural language, enabling deep, interactive investigation of the issues. Click here to sign up for preview.

Advancing Full-Stack Observability with Azure Monitor at Ignite 2025

Shiva_Sivakumar — Thu, 20 Nov 2025 18:48:08 GMT

New AI-powered innovations in the observability space

First, we’re excited to usher in the era of agentic cloud operations with Azure Copilot agents. At Ignite 2025, we are announcing the preview of the Azure Copilot observability agent to help you enhance full-stack troubleshooting. Formerly “Azure Monitor investigate”, the observability agent streamlines troubleshooting across application services and resources such as AKS and VMs with advanced root cause analysis in alerts, the portal, and Azure Copilot (gated preview). By automatically correlating telemetry across resources and surfacing actionable findings, it empowers teams to resolve issues faster, gain deeper visibility, and collaborate effectively. Learn more here about the observability agent and learn about additional agents in Azure Copilot here.

Additionally, with the new Azure Copilot, we are streamlining agentic experiences across Azure. From operations center in the Azure portal, you can get a single view to navigate, operate and optimize your environments and invoke agents in your workflows. You also get suggested top actions within the observability blade of operations center to prioritize, diagnose and resolve issues with support from the observability agent. Learn more here.

In the era of AI, more and more apps are now AI apps. That’s why we’re enhancing our observability capabilities for GenAI and agents: Azure Monitor brings agent-level visibility and control into a single experience in partnership with Observability in Foundry Control Plane through a new agent details view (public preview) showcasing success metrics, quality indicators, safety checks, and cost insights in one place. Simplified tracing also transforms every agent run into a reasonable, plan-and-act narrative for faster understanding. On top of these features, the new smart trace search enables faster detection of anomalies—such as policy violations, unexpected cost spikes, or model regressions—so teams can troubleshoot and optimize with confidence. These new agentic experiences build upon a solid observability foundation provided by Azure Monitor. Learn more here.

We’re making several additional improvements in Azure Monitor:

Simplified Onboarding & More Centralized Visibility

Streamlined onboarding: Azure Monitor now offers streamlined onboarding for VMs, containers, and applications with sensible defaults and abstraction layers. This means ITOps teams can enable monitoring across environments in minutes, not hours. Previously, configuring DCRs and linking Log Analytics workspaces was a multi-step process; now, you can apply predefined templates and scale monitoring across hundreds of VMs faster than before.
Centralized dashboards: A new monitor overview page in operations center consolidates top suggested actions and Azure Copilot-driven workflows for rapid investigation. Paired with the new monitoring coverage page (public preview) in Azure Monitor, ITOps can quickly identify gaps based on Azure Advisor recommendations, enable VM Insights and Container Insights at scale, and act on monitoring recommendations—all from a single pane of glass. Learn more here.
Richer visualizations: Azure Monitor dashboards with Grafana are now in GA, delivering rich visualizations and data transformation capabilities on Prometheus metrics, Azure resource metrics, and more. Learn more here.
Cloud to edge visibility: With expanded support for Arc-enabled Kubernetes with OpenShift and Azure Red Hat OpenShift in Container Insights and Managed Prometheus, Azure Monitor offers an even more complete set of services for monitoring the health and performance of different layers of Kubernetes infrastructure and the applications that depend on it. Learn more here.

Advanced Logs, Metrics, and Alert Management

Logs & metrics innovations: Azure Monitor now supports the log filtering and transformation (GA), as well as the emission of logs to additional destinations (public preview) such as Azure Data Explorer and Fabric—unlocking real-time analytics and more seamless data control. Learn more here.
More granular access for managing logs: Granular RBAC for Log Analytics workspaces ensures compliance and least privilege principles across teams, now in general availability. Learn more here.
Dynamic thresholds for log search alerts (public preview): Now you can apply the advanced machine learning methods of dynamic threshold calculations to enhance monitoring with log search alerts. Learn more here.
Query-based metric alerts (public preview): Get rich and flexible query-based alerting on Prometheus, VM Guest OS, and custom OTel metrics to reduce complexity and unblock advanced alerting scenarios. Learn more here.

OpenTelemetry Ecosystem Expansion

Azure Monitor doubles down on our commitment to OpenTelemetry with expanded support for monitoring applications deployed to Azure Kubernetes Service (AKS) by using OTLP for instrumentation and data collection. New capabilities include:

Auto-instrumentation with the Azure Monitor OpenTelemetry distro for Java and NodeJS apps on AKS (public preview): this reduces friction for teams adopting OTel standards and ensures consistent telemetry across diverse compute environments.
Auto-configuration for apps on AKS in any language already instrumented with the open-source OpenTelemetry SDK to emit telemetry to Azure Monitor. Learn more here.

Additionally, we are making it easier to gain richer and more consistent visibility across Azure VMs and Arc Servers with OpenTelemetry visualizations, offering standardized system metrics, per-process insights, and extensibility to popular workloads on a more cost-efficient and performant solution. Learn more here.

Next Steps

These innovations redefine observability from cloud to edge—simplifying onboarding, accelerating troubleshooting, and embracing open standards. For ITOps and DevOps teams, this means fewer blind spots, faster MTTR, and improved operational resilience.

Whether you’re joining us at Microsoft Ignite 2025 in-person or online, there are plenty of ways to connect with the Azure Monitor team and learn more:

Attend breakout session BRK149 for a deep dive into Azure Monitor’s observability capabilities and best practices for optimizing cloud resources.
Attend breakout session BRK145 to learn more about how agentic AI can help you streamline cloud operations and management.
Attend breakout session BRK190 to learn about how Azure Monitor and Microsoft Foundry deliver an end-to-end observability experience for your AI apps and agents.
Join theater demo THR735 to see a live demo on monitoring AI agents in production.
Connect with Microsoft experts at the Azure Copilot, Operations, and Management expert meet-up booth to get your questions answered.

Introducing Monitoring Coverage: Assess and Improve Your Monitoring Posture at Scale

Nathan_Mangum — Tue, 18 Nov 2025 16:00:00 GMT

As organizations grow their Azure footprint, ensuring consistent monitoring coverage across resources becomes increasingly important. The new Monitoring Coverage (preview) feature in Azure Monitor provides a single, centralized experience to assess, configure at-scale, and enhance monitoring across your environment with ease.

A unified view of your monitoring health

Monitoring Coverage consolidates insights from Azure Advisor to highlight where monitoring can be improved. You can see which Azure resources already have basic out-of-box telemetry enabled and which could benefit from additional recommended settings, helping you close gaps in your observability strategy at scale.

Key capabilities

Comprehensive visibility: Get an overview of monitoring coverage across common Azure resource types.
Actionable recommendations: Identify and apply Azure Advisor recommendations at-scale to strengthen your monitoring posture.
Centralized configuration: Enable recommended monitoring settings for multiple resources from a single pane of glass.
Detailed resource insights: Explore individual resource details to review active monitoring configurations and applicable recommendations.

How to access

In the Azure portal, open Azure Monitor. Under the Settings section of the left navigation, select Monitoring Coverage (preview). You can scope the view using standard Azure filters; Subscriptions, Resource groups, Tags, Locations, and Resource types, allowing you to focus on the resources you manage.

Supported resource types

During preview, Monitoring Coverage supports Virtual Machines (VMs) and Azure Kubernetes Service (AKS) clusters. Support for additional Azure services will roll out in future updates.

Overview tab

The Overview tab provides a snapshot of your overall monitoring landscape, showing which resources have:

Basic monitoring: Default metrics and logs enabled upon creation.
Enhanced monitoring: Microsoft-recommended configurations for deeper insights and improved observability.

This view makes it easy to identify coverage gaps and take quick action to enable enhanced monitoring, which may incur additional cost depending on your configuration.

Streamlined enablement experience

When you choose to enable monitoring:

The Enablement screen lists all resources included in the operation.
You can deselect specific resources if needed.
Selecting View details and configure allows customization by resource type—for example, selecting a Log Analytics workspace.
The Review and Enable tab summarizes all changes before application.
Once enabled, data typically begins flowing to the designated workspace within 30–60 minutes.

During this preview, you can enable monitoring for up to 100 resources at a time, and an existing Log Analytics workspace or Azure Monitor Workspace is required.

Monitoring Details page

For a deeper look, the Monitoring Details page lets you:

View resources as a list or group them by recommendation.
Filter using standard Azure filters.
See the Monitoring coverage column summarizing enabled recommendations and data collection rules.
Enable individual monitoring settings directly from this view when managing resources one at a time.

Share your feedback

We’re actively evolving Monitoring Coverage based on user input. To share your feedback or suggest new capabilities, use the Feedback link at the top of the page in the Azure portal. Your insights will help shape the future of Azure Monitor.

Try Monitoring Coverage (preview) today in the Azure portal to assess your observability coverage and take the next step toward proactive, consistent monitoring across your Azure environment.

PUBLIC PREVIEW: Announcing public preview of dynamic thresholds for log search alerts

Efrat_Ben_Porat — Tue, 18 Nov 2025 16:00:00 GMT

We’re excited to announce the public preview of dynamic thresholds for log search alerts in Azure Monitor! This capability builds on dynamic thresholds for metric alerts capability and brings the same intelligence to log-based monitoring.

Dynamic threshold for log alerts preview chart displayed when setting up a new alert rule

What are dynamic thresholds?

Dynamic thresholds help remove the guesswork from setting alert conditions. Instead of manually defining static thresholds, Azure Monitor uses advanced machine learning to:

Learn historical behavior of your log query results
Detect hourly, daily, and weekly seasonal patterns
Calculate the most appropriate thresholds for each alert rule
Adapt automatically as data patterns change

Why it matters

Simplified configuration: No need to fine-tune thresholds manually
Adaptive monitoring: Alerts adjust automatically to changing trends
At-scale intelligence: For multi-dimensional monitoring, thresholds are calculated per dimension combination

Example use cases

AKS Pod restart spike anomaly detection

Scenario: Monitor Kubernetes Pod logs for spikes in pod restarts across clusters.
Why dynamic thresholds help:

AKS workloads often scale dynamically; static thresholds can’t account for autoscaling patterns.
Dynamic thresholds adapt to normal fluctuations in node/pod counts and alert only on true anomalies.

Example query:

KubePodInventory | summarize restartCount = sum(PodRestartCount) by bin(TimeGenerated, 10m), ClusterName, Namespace, Name

Dynamic threshold settings:

Measure: restartCount (the aggregated column from the query).
Split by dimensions (optional):

Namespace (for workload-level baselines).
Name (for per-pod granularity if needed).

Resource Inventory Drift Detection (Azure Resource Graph)

Scenario: Detect sudden spikes in resource creation or deletion across subscriptions or management groups utilizing Log search alerts integration with Azure Resource Graph that may indicate runaway deployments.
Why dynamic thresholds help:

Large organizations often have thousands of resources with varying deployment patterns.
Static thresholds can’t account for seasonal changes (e.g., monthly deployments, scaling events).
Dynamic thresholds adapt per subscription or resource type, reducing false positives.

Example query:

arg("").Resources | summarize resourceCount = count() by type, subscriptionId

Dynamic threshold settings:

Measure: resourceCount (the aggregated column from the query).
Split by dimensions (optional):

type (for specific resource type changes).
subscriptionId (for per-subscription granularity).

Getting Started

Learn more about Log Search Alerts with Dynamic Thresholds and how to set up alert rules in Azure Monitor.

Public Preview: Azure Monitor Integration with Fabric Real Time Intelligence Eventhouse

AprilBadger — Tue, 18 Nov 2025 15:44:22 GMT

Customers need to enable different scenarios to successfully operate their IT/OT environments and business processes for meeting business objectives. Building solutions to solve these problems requires deriving rich insights from telemetry data emitted by devices, assets, applications, typically, by combining with other data to answer business questions. The common need for the systems that produce the insights is the ability to obtain the data they need within acceptable latency, to process, produce and serve up the insights in the most actionable manner. Integrating Azure Monitor with Fabric Real Time Intelligence Eventhouseenables customers to build solutions to uncover business insights and trends.

What's New

The demand for leveraging telemetry data beyond observability scenarios is steadily increasing. Some examples include:

To drive capacity management processes, utilization telemetry is mapped to inventory data.
Correlating support ticket and resolution times with service performance telemetry to estimate engineering hours per dollar.

With this new capability, customers can seamlessly leverage telemetry data collected via Azure Monitor for advanced analytics through a Fabric Real Time Intelligence Eventhouse, enabling comprehensive visualization and analysis of such scenarios. This public preview supports various event types from Windows and Linux-based Virtual Machines. Through the use of Data Collection Rules (DCR), customers maintain granular control over sending data to a Fabric Real Time Intelligence Eventhouse. By leveraging these platforms, organizations can monitor and enhance data-driven decision-making, boost operational efficiency, and strengthen business process and insights.

Key Benefits

Extensive Data Ingestion: Supports a wide range of telemetry types, including Windows event logs, Linux syslog, performance counters, IIS logs, and custom logs.
Comprehensive Advanced Analytics: Leverage Fabric Real Time Intelligence Eventhouse for robust querying and visualization capabilities across Azure Monitor collected telemetry and other business data.
Seamless Integration: Reduce implementation time by easily connecting existing Azure Monitor setups with Fabric Real Time Intelligence Eventhouse.

You can access this feature directly from the Azure Portal in just a few steps:

1. Use the new Data Collection Rule creation experience to add a dataflow for any of the supported telemetry types.

2. Configure an existing Fabric Real Time Intelligence Eventhouse database as your destination. Optionally, you may create a new destination from this UI.

3. Within minutes after your Data Collection Rule (DCR) is deployed, you will see logs in your Fabric environment. From here you can query or build analytics on this and other available datasets.

We invite you to explore this new feature in public preview and experience how it can transform your data monitoring and analytics workflows. For more details on getting started, please visit the Azure Monitor documentation.

Comprehensive VM Monitoring with OpenTelemetry performance counters

viviandiec — Tue, 18 Nov 2025 16:00:00 GMT

Monitoring virtual machines often requires multiple tools and manual investigation. You may see high CPU or memory usage, but identifying the process responsible usually means signing in to the VM and running diagnostic commands.

Azure Monitor already provides Guest OS performance monitoring through Log Analytics‑based metrics, trusted for its flexibility, deep integration, and advanced analytics, including custom performance counters, extended retention, and powerful KQL queries. Many customers use LA‑based metrics to correlate performance with other log data sources and build rich operational insights.

Today, we’re excited to introduce a new preview capability: OpenTelemetry (OTel) Guest OS metrics for VMs and Arc servers, with metric data stored in the metrics-optimized Azure Monitor Workspace (AMW). OTel provides a standards‑based pipeline with a unified schema, richer system and process counters, and streamlined integration with open‑source and cloud‑native observability tooling. It’s designed for simpler onboarding, cost‑efficient metric storage, and more granular visibility into what’s happening inside the VM.

What are OpenTelemetry Guest OS metrics

OTel Guest OS metrics are system and process‑level performance counters collected from inside a VM. This includes CPU, memory, disk I/O, network, and per‑process details such as CPU percent, memory percent, uptime, and thread count. This level of visibility helps you diagnose issues without signing into the VM.

Why They Matter

Azure Monitor continues to support Guest OS metrics through Log Analytics, and you now have the option to use OTel‑based Guest OS metrics. OTel offers richer insights, faster query performance, and lower cost, and is a good fit when you want a modern, standards‑based pipeline with deeper system visibility.

Key Benefits

Benefit	Description
Unified data model	Consistent metric names and schema across Windows and Linux for easier, reusable queries and dashboards
Richer, simplified counters	More system and process metrics (e.g., per‑process CPU, memory, disk I/O) and consolidation of legacy counters into clearer OTel metrics.
Easy onboarding	Collect OTel metrics with minimal setup.
Flexible visualization	Use the Azure portal, Metrics Explorer, or Azure Monitor Dashboards with Grafana.
Cost‑efficient performance	Store metrics in Azure Monitor Workspace instead of Log Analytics ingestion for lower cost and faster queries.

When to use LA‑based metrics (GA) vs OTel‑based metrics (Preview)

LA-based metrics (GA)	OTel-based metrics (Preview)
Custom performance counters or extended retention Advanced KQL analytics and log‑metric correlation A mature, fully supported pipeline for operational analytics	A standards‑based, unified schema across platforms Easier onboarding and broader system/process coverage Cost‑efficient metric storage with improved query performance

We recommend evaluating your requirements to determine which approach best fits your needs. LA-based metrics remain the foundation for customers who need advanced analytics and correlation, while OTel-based metrics open new possibilities for modern VM observability.

Onboarding VMs to OpenTelemetry performance counters

Onboarding your virtual machines and Arc servers to OpenTelemetry-based counters is now both cost-efficient and easier than ever. With the new onboarding experience, you can enable guest-level metrics using a lightweight, standards-based OTel pipeline with no complex setup required. These system-level counters are available at no additional cost and provide deep visibility into CPU, memory, disk, network, and process activity from inside the VM. Azure Monitor automatically configures your Data Collection Rules (DCRs) to route these OpenTelemetry counters through the Monitor pipeline, ensuring you get full monitoring coverage with minimal configuration.

Single-VM onboarding screen showing the option to enable OpenTelemetry-based counters

Additionally, you can also onboard your VMs at scale using the new Monitoring Coverage experience or Essential Machine Management (EMM). For teams managing large fleets of virtual machines, these capabilities turn onboarding into a one-click operation, eliminating the need to repeat manual steps for each machine. This is especially valuable in enterprises or environments with dynamic VM creation, where maintaining consistent visibility across every machine is critical for performance, compliance, and troubleshooting.

Monitoring Coverage screen showing the ability to enable OpenTelemetry-based counters at scale

After onboarding at scale, you can further customize your monitoring. By editing the Data Collection Rule (DCR) created during onboarding, you can collect additional metrics and logs, then automatically apply those updates across all VMs associated with that DCR. This allows you to extend monitoring coverage beyond the default counters and adapt to your observability as your environment evolves.

New Capabilities Powered by OpenTelemetry

New VM monitoring experience powered by OpenTelemetry (preview)

We're excited to announce the public preview of the enhanced monitoring experience for Azure Virtual Machines (VMs) and Arc servers. This redesign brings comprehensive monitoring capabilities in a single, streamlined view, helping you more efficiently observe, diagnose, and optimize your virtual machines.

The new experience offers two levels of insight within one unified interface:

Basic view (Host OS based): Available for all Azure VMs with no configuration required. This view surfaces key host level metrics including CPU, disk, and network performance for quick health checks.
Detailed view (Guest OS based): Requires a simple onboarding step and is available at no additional cost. Azure Monitor already provides a GA detailed view powered by Log Analytics based Guest OS metrics, and this remains fully supported. This preview option is powered by OTel Guest OS metrics to provide expanded metric coverage and the new, streamlined monitoring experience introduced above

Detailed view (Guest OS based with OTel) and enhanced monitoring experience for VMs

You can access the new experience directly in the Azure portal under Virtual Machine → Monitoring → Insights.

Building Custom Dashboards with Azure Monitor Dashboards in Grafana

Azure Monitor Dashboards with Grafana lets you build custom visualizations on top of OTel Guest OS metrics. In addition to the out-of-the-box VM monitoring experience, you can create tailored dashboards to analyze the specific system or process-level signals that matter most to your workloads.

For example, you can build a dashboard that breaks down CPU, memory, disk, and network usage at the process level. This helps you quickly identify unusual behavior or resource hotspots without signing in to the VM. Learn more.

Custom Grafana dashboard to analyze process-level signals (CPU, memory, disk)

Query-based metric alerts (preview)

Azure Monitor now supports PromQL-based metric alerts for OTel metrics stored in Azure Monitor Workspace, enabling flexible and powerful query-driven alerting.

For example, you can configure an alert to notify you when a specific process shows unusual CPU usage, allowing you to detect issues earlier and take action before they impact users.

PromQL based metric alert that triggers when the backupdatawarehouse.exe process exceeds 80% memory usage

Get Started

Explore the new OpenTelemetry-powered experiences today:

We are also starting a limited public preview of application monitoring with OpenTelemetry signal collection from Azure VMs, VMSS and Arc Server. Learn more.

Together, these previews mark a major step toward a unified and open monitoring platform designed to make observability simpler, faster, and aligned with open standards across every layer of your environment.