Monitoring and Troubleshooting Integrations with Azure Application Insights and Azure Monitor

The Foundation: Azure Monitor and Application Insights

Before we dive into the "how," let's clarify the "what." The primary monitoring services in Azure are Azure Monitor and Application Insights.

To get a clear picture of their roles, please watch this short introductory video from Microsoft.

As you saw, Azure Monitor is the umbrella service. Application Insights is a feature within Azure Monitor, specifically designed as an Application Performance Management (APM) service. It gives us rich tools to monitor our applications, detect issues, and analyze telemetry.

To see Application Insights in action, let's watch a more detailed tutorial.

Now that we have a solid conceptual understanding, let's get practical and connect our Power Platform components to Application Insights.

Instrumenting Your Solution for Telemetry

A key principle of modern monitoring is to have a single "pane of glass" where you can see telemetry from all parts of your application. To achieve this, we'll create one Application Insights resource in Azure and configure our various components—plugins, apps, and Azure services—to send their logs to it.

1. Connecting Server-Side Logic: Dataverse Plugins

Your extensive experience with plugin development likely involved using the ITracingService to write logs to the PluginTraceLog table in Dataverse. While useful for immediate debugging, this method has limitations: logs expire after 24 hours and are isolated from the rest of your application's telemetry.

The modern approach, which integrates perfectly with Application Insights, is to use the ILogger interface.

This article from the Dynamics community provides a fantastic guide on setting this up.

The process is straightforward:

1. Create the Application Insights resource in Azure.
2. Connect it in the Power Platform Admin Center (admin.powerplatform.microsoft.com) under Data export.
3. Update your plugin code to use the ILogger interface.

Once configured, any logs you write using ILogger in your plugins will automatically be sent to your central Application Insights instance.

2. Connecting Client-Side Logic: Canvas Apps

Just as we capture server-side events, we also need to understand what's happening on the client side in our Canvas Apps. Application Insights provides a direct integration for this.

By simply providing the connection string, you automatically get telemetry on user sessions, devices, and browser types. More importantly, the Trace() function gives you granular control to log specific events, errors, and contextual data, which is invaluable for debugging complex user interactions.

For example: Trace("PaymentSubmitted", TraceSeverity.Information, { OrderID: varOrderID, Amount: txtAmount.Text })

3. Connecting Azure Integration Components

In our previous lesson, we discussed using Azure Data Factory and Azure Functions. A major benefit of this architecture is that these Azure services can also be configured to log to the exact same Application Insights instance, giving you a unified view. As demonstrated in the "Azure Application Insights Tutorial" video, connecting an Azure Function is typically a simple configuration step during its creation or in its settings, with no code changes required for basic telemetry.

Analysis and Troubleshooting in Application Insights

With telemetry flowing in from our plugins, apps, and Azure services, we can now use Application Insights' powerful tools to monitor and troubleshoot.

The Big Picture: Application Map

Your first stop when investigating a complex integration should be the Application Map. It automatically visualizes the components of your system and the dependencies between them, overlaying performance data and error rates.

Imagine one of the data synchronization pipelines from our last lesson. An Application Map could visually represent the flow from a Dataverse plugin trigger, to an Azure Service Bus queue, to an Azure Function that processes the data and writes it to Azure SQL. A spike in errors on the Function or a high latency on the SQL call would be immediately visible.

Real-time Debugging: Live Metrics Stream

When you are actively developing or need to see what's happening right now in production, the Live Metrics Stream is your tool. It provides a real-time (sub-second latency) view of incoming requests, dependencies, and traces. It's perfect for verifying that your new plugin is firing correctly or for watching for specific errors as a user reproduces a bug.

Investigating Failures and Performance

The Failures and Performance tabs under the "Investigate" section are where you'll spend much of your troubleshooting time.

• Failures: This view aggregates all exceptions, HTTP errors, and other failures. It groups them by problem type, allowing you to focus on the most frequent issues. You can select a specific failure to see all related transactions.
• Performance: This view shows the performance of various operations and dependencies, helping you identify bottlenecks.

From either of these views, you can drill down into an "End-to-end transaction detail" view.

Deep Dives with Kusto Query Language (KQL)

For any question that can't be answered by the pre-built views, you have the Logs pane, which allows you to run queries against your raw telemetry data using the Kusto Query Language (KQL).

KQL is a powerful, read-only query language designed for analyzing large datasets. Its syntax is similar to SQL but with a pipe-through (|) structure that you may find reminiscent of shell command piping.

For example, to find all the custom feedback traces we sent from our Canvas App:

traces
| where message == "App Feedback"
| extend customdims = parse_json(customDimensions)
| project timestamp, AppName = customdims.['ms-appName'], FeedbackFrom = customdims.UserEmail, Screen = customdims.Screen, FeedbackValue = customdims.FeedbackValue
| order by timestamp desc

Conclusion

You have now learned how to create a comprehensive monitoring strategy for your Power Platform solutions. By centralizing telemetry from Dataverse, Canvas Apps, and Azure services into Application Insights, you gain powerful capabilities for troubleshooting and performance optimization.

Key Takeaways:

• Azure Monitor is the overarching platform; Application Insights is the APM service we use for detailed analysis.
• Use the ILogger interface in plugins and the Trace() function in Canvas Apps to send rich, contextual telemetry.
• Always connect all components of an integration (e.g., Dataverse, Azure Functions, Web Apps) to the same Application Insights instance for unified monitoring.
• Use a systematic approach to troubleshooting:
  • Start with the Application Map for a high-level overview.
  • Use Live Metrics for real-time issues.
  • Drill down into specific issues with the Failures and Performance tabs.
  • Answer any custom question with Logs and KQL.

This knowledge is essential for moving beyond development and into the realm of building and maintaining reliable, production-ready enterprise applications.

What's Next?

We've now covered a significant portion of the integration and architecture topics in the PL-400 curriculum. The next step is to focus on professional deployment practices. In our next lesson, we will kick off the final module, "Professional ALM and DevOps," by learning how to implement connection references and environment variables for deployment flexibility across environments. This will set the stage for building automated deployment pipelines.