Canvas App Integration with Application Insights

1. From Debugging to Production Analytics

While Monitor is excellent for a developer's interactive session, it's not designed for continuous, unattended monitoring of all user sessions. Application Insights, a feature of Azure Monitor, fills this gap by providing a scalable service to:

• Collect telemetry data from your published apps.
• Analyze user behavior, performance metrics, and errors using a powerful query language.
• Visualize this data in dashboards and reports.
• Alert you proactively when things go wrong.

2. Setting Up the Integration

The first step is to create an Application Insights resource in Azure and then link your Canvas App to it. The process is straightforward and relies on a connection string.

The official Microsoft documentation provides a clear, step-by-step guide. Please read through the initial sections to understand the setup process.

Once you retrieve the connection string from your Application Insights resource in the Azure portal, you simply paste it into the corresponding property on the App object in your Canvas App.

After saving and publishing your app, it will automatically start sending telemetry data.

Important Note: Some older articles or community posts might refer to an "Instrumentation Key." This is a legacy method. The Connection String is the current and recommended approach.

3. Understanding Automatic Telemetry

Once connected, your app immediately starts sending valuable telemetry without any additional code. This includes:

• Page Views: Every time a user navigates to a screen.
• User Sessions: Grouping user activity into sessions.
• Client-side details: Browser type, operating system, user's country/region.
• App Lifecycle Events: Information about app load times and success rates.

You can explore this data directly in the Azure portal. The Users, Events, and Performance blades in Application Insights provide rich, out-of-the-box visualizations.

The community blog post "Monitoring the Power Platform: Canvas Apps" provides a good summary of the different tables where this automatic data lands in Application Insights.

4. Implementing Custom Telemetry with Trace()

While automatic telemetry is useful, the real power for a developer comes from logging custom events. This is where you move from generic monitoring to answering specific questions about your application, such as:

• Which features are used most often?
• How long does a specific, multi-step business process take for the user?
• What were the specific input values when a non-critical warning occurred?

In Power Apps, you achieve this using the Trace() function. Its syntax is:

Trace( message, [severity], [custom_record] )

• message: A string that describes the event (e.g., "SaveButton Clicked").
• severity (Optional): An enumeration (TraceSeverity.Information, TraceSeverity.Warning, TraceSeverity.Error). This is analogous to log levels in other frameworks.
• custom_record (Optional): A record containing custom key-value pairs. This is where you add the rich contextual data that makes your telemetry so valuable.

Let's walk through the excellent example from the Microsoft Learn documentation on how to implement this.

Here is the core of the example formula:

Trace(
    "App Feedback",  // Message
    TraceSeverity.Information,  // Severity
    {   // Custom Data Record
        UserName: User().FullName,
        UserEmail: User().Email,
        Screen: App.ActiveScreen.Name,
        FeedbackValue: "1"
    }
);

This single line of code sends a structured log to Application Insights that tells you who gave feedback, what screen they were on, and what their feedback was. This is far more powerful than a simple text log.

5. Analyzing Custom Data with KQL

Collecting data is only half the story. You need to be able to query and analyze it. In Application Insights, this is done using the Kusto Query Language (KQL). KQL is a powerful, read-only query language designed for analyzing large datasets, and it's a critical skill for working with Azure monitoring services.

All events sent via the Trace() function land in the traces table in Application Insights Logs. The custom data you provided is stored as a JSON object in the customDimensions column.

To analyze this data, you'll need to parse this JSON. The Microsoft Learn article shows exactly how to do this.

The key KQL query pattern looks like this:

traces
| where message == "App Feedback"
| extend customdims = parse_json(customDimensions)
| project
    timestamp,
    message,
    FeedbackFrom = customdims.UserEmail,
    Screen = customdims.Screen,
    FeedbackValue = customdims.FeedbackValue
| order by timestamp desc

This query finds all "App Feedback" traces, expands the custom dimensions, and projects them as top-level columns, making the data easy to read and aggregate.

Trace(
    "FormSaved",
    TraceSeverity.Information,
    {
        FormName: "ProjectDetailsForm",
        TimeSpentOnForm: (Now() - varFormOpenedTime) / 1000, // Time in seconds
        ItemsInSubgrid: CountRows(SubgridGallery.AllItems)
    }
)

traces
| where message == "FormSaved"
| extend customdims = parse_json(customDimensions)
| extend TimeSpent = toreal(customdims.TimeSpentOnForm) // Convert to a numeric type for comparison
| where TimeSpent > 60
| project
    timestamp,
    FormName = customdims.FormName,
    ItemsInSubgrid = customdims.ItemsInSubgrid
| order by timestamp desc

Conclusion

You have now learned how to equip your Canvas Apps with professional-grade telemetry using Application Insights. This capability elevates your applications from simple tools to managed assets, allowing you to proactively monitor their health, understand user engagement, and make informed decisions for future enhancements.

Key Takeaways:

• Application Insights is for production monitoring, capturing telemetry from all user sessions.
• The integration is simple: create a resource in Azure and add the Connection String to your app's properties.
• The Trace(message, severity, custom_record) function is your tool for sending custom, structured telemetry. This is essential for detailed analytics.
• KQL is the language used to query and analyze the collected data in the Application Insights Logs workspace, allowing you to parse custom dimensions and gain deep insights.

Up Next:

Now that you've mastered monitoring and debugging, our next step is to enhance your app's data integration capabilities. In the following lesson, you will learn how to consume data from a pre-built custom connector within a Canvas App. This will open the door to connecting your apps to virtually any REST API, a cornerstone of advanced Power Platform development.