Dynamics Community Forum Thread Details

Hello BK-17051419-0,

You're right, standard Dataverse auditing provides a good overview of who accessed and changed records, but it doesn't inherently capture the full details of every Web API request, including payloads and specific error responses, in a readily accessible, out-of-the-box view.

However, there are several ways you can achieve more detailed logging and monitoring of your Web API requests, including failed ones and their payloads:

1. Leverage Azure Application Insights:

This is the most robust and recommended approach for comprehensive monitoring of your Dataverse Web API interactions.

How it Works: You can configure your Dataverse environment to send telemetry data, including Web API requests and responses, to Azure Application Insights.

Benefits:
- Detailed Request/Response Logging: Captures headers, bodies (payloads), status codes, and response times.
- Error Tracking: Automatically tracks exceptions and failures, providing detailed stack traces.
- Performance Monitoring: Offers insights into API performance and identifies potential bottlenecks.
- Powerful Querying: Provides a rich query language (Kusto Query Language - KQL) to analyze your API data.
- Alerting: You can set up alerts based on specific error conditions or performance thresholds.

Implementation:
1. Create an Azure Application Insights resource in your Azure subscription.
2. Configure Dataverse to send telemetry to Application Insights. This typically involves using the Power Platform Admin Center. Look for settings related to monitoring or diagnostics and connect it to your Application Insights instance using its Instrumentation Key. The exact steps might vary slightly depending on your Power Platform version, so consult the official Microsoft documentation for "Monitor Power Apps and Dataverse services in Application Insights."
3. Explore data in Application Insights: Once configured, you can use the "traces," "requests," and "exceptions" tables in Application Insights to view detailed information about your Web API calls. You can filter by user (your app user), operation name (e.g., Update), and status code to identify failed requests and inspect their details.

2. Implement Custom Logging within Your App User's Logic:

If you have control over the application code that's making the Web API calls using the app user, you can implement custom logging within your application.

How it Works: In your application's code, log the details of each Web API request (method, URL, headers, payload) before sending it. Also, log the response status code and the response body, especially for error responses.

Benefits:
- Full Control over Logging: You can log exactly what you need.
- Integration with Your Existing Logging: You can integrate this logging with your application's existing logging framework.

Considerations:
- Development Effort: Requires modifying your application code.
- Storage and Management: You'll need to decide where to store and how to manage these logs (e.g., file system, Azure Blob Storage, a dedicated logging service).

3. Utilize Network Tracing Tools (for Debugging):

While not a long-term monitoring solution, network tracing tools can be invaluable for debugging Web API interactions in real-time.

How it Works: Tools like Fiddler (for Windows) or browser developer tools (Network tab) can capture HTTP requests and responses between your application and the Dataverse Web API.

Benefits:
- Real-time Inspection: Allows you to see the exact requests being sent and the responses received.
- Payload Visibility: You can inspect the request and response bodies.
- Error Details: Provides HTTP status codes and error messages.

Limitations:
- Primarily for Development/Debugging: Not suitable for continuous monitoring in a production environment.
- Requires Running the Tool Locally: You need to have the tracing tool running on the machine making the API calls.

4. Check Server-Side Tracing (Less User-Friendly for Web API):

Dataverse has server-side tracing capabilities that can log detailed information about platform operations, including plugin execution and Web API calls.

How it Works: You can enable tracing for specific users or operations. The traces are stored within Dataverse.

Benefits:
- Detailed Platform Logs: Can provide insights into the server-side processing of your API requests.

Limitations:
- Can be Verbose: Traces can generate a lot of data, making it difficult to find specific Web API request details.
- Not Designed for Payload Inspection: While it might log some relevant information, it's not primarily designed to capture full request and response payloads in an easily digestible format for Web API debugging.
- Management Overhead: Managing and reviewing traces can be cumbersome.

Recommendation:

The most comprehensive and scalable solution for monitoring your Web API requests, including failures and payloads, is to integrate Azure Application Insights with your Dataverse environment. It provides a dedicated platform for monitoring application performance and health, with powerful tools for analyzing your API interactions.

Implementing custom logging in your application is a good supplementary approach, especially if you need very specific logging details tailored to your application's logic. Network tracing tools are excellent for development and immediate debugging. Server-side tracing can be helpful for deeper platform-level issues but is less suited for routine Web API monitoring.

By implementing one or a combination of these methods, you'll gain the visibility you need into your Web API requests and be able to effectively troubleshoot any issues.

If my answer was helpful, please click Like, and if it solved your problem, please mark it as verified to help other community members find more. If you have further questions, please feel free to contact me.

My response was crafted with AI assistance and tailored to provide detailed and actionable guidance for your Microsoft Dynamics 365 query.

Regards,

Daivat Vartak