using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Sdk.PluginTelemetry;
using System;

namespace JJG.Plugins.AppInsightsSample.Helper
{
   /// <summary>
   /// Class used to consolidate all Tracing / Logger calls into a single action.
   /// </summary>
   public class Logger
   {
      private readonly ITracingService tracer;
      private readonly ILogger logger;
      public Logger(IServiceProvider serviceProvider)
      {
         tracer = (ITracingService)serviceProvider.GetService(typeof(ITracingService));
         logger = (ILogger)serviceProvider.GetService(typeof(ILogger));
      }
      /// <summary>
      /// Logs information out to the Trace Log and Application Insights resource for the current environment.
      /// </summary>
      /// <param name="log">The actual message to log out.</param>
      public void LogInformation(string log)
      {
         logger.LogInformation(log);
         tracer.Trace(log);
      }
      /// <summary>
      /// Logs an error out to the Trace Log and Application Insights resource for the current environment.
      /// </summary>
      /// <param name="log">The actual message to log out.</param>
      /// <param name="log">Exception details to log out into Application Insights.</param>
      public void LogError(string log, Exception ex)
      {
         logger.LogError(ex, log);
         tracer.Trace(log);
      }
   }
}

using System;
using System.ServiceModel;
using Microsoft.Xrm.Sdk;
using JJG.Plugins.AppInsightsSample.Helper;
using System.Collections.Generic;

namespace JJG.Plugins.AppInsightsSample
{
   public class Case_OnUpdate_PushAppInsightsSample : IPlugin
   {
      private int facebookCaseOrigin = 2483;
      public void Execute(IServiceProvider serviceProvider)
      {
         //Obtain the execution context from the service provider.

         IPluginExecutionContext context = (IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));

         // Check for EntityType and Message supported by your Plug-In
         if (context.MessageName != "Update" && context.PrimaryEntityName != "incident")
            throw new InvalidPluginExecutionException($"Plug-In {this.GetType()} is not supported for message " +
                                                      $"{context.MessageName} of {context.PrimaryEntityName}");

         //Initialize Tracing / Logger for Application Insights - custom class used to simplify the calls
         Logger logger = new Logger(serviceProvider);
         logger.LogInformation("Tracing / Logging implemented successfully!");

         try
         {          
            //For the sample, just create a couple of Tasks on the Case and output details to logging.
            //Also simulate an error scenario, based on the Case Origin value

            Entity incident = (Entity)context.InputParameters["Target"];
            Entity postIncident = context.PostEntityImages["PostImage"];
            logger.LogInformation($"Case ID: {incident.Id}");
            OptionSetValue incidentOrigin = postIncident.GetAttributeValue<OptionSetValue>("caseorigincode");
            logger.LogInformation($"Origin (Value): {incidentOrigin.Value}");

            if (incidentOrigin.Value == facebookCaseOrigin)
            {
               string error = $"Invalid Case Origin specified. Facebook Origin's are not allowed.";
               throw new InvalidPluginExecutionException(error);
            }
            else
            {
               logger.LogInformation($"Creating Tasks for Case ID {incident.Id}");

               //Get a reference to the Organization service.
               IOrganizationServiceFactory factory = (IOrganizationServiceFactory)serviceProvider.GetService(typeof(IOrganizationServiceFactory));
               IOrganizationService service = factory.CreateOrganizationService(context.UserId);

               List<int> taskNumbers = new List<int>()
               {
                  1,2,3,4
               };

               foreach(int number in taskNumbers)
               {
                  logger.LogInformation($"Processing Task # {number}...");
                  Entity task = new Entity("task");
                  task["subject"] = $"Case Task # {number}";
                  task["scheduledend"] = DateTime.UtcNow.AddDays(7);
                  task["regardingobjectid"] = new EntityReference("incident", incident.Id);
                  Guid taskID = service.Create(task);
                  logger.LogInformation($"Task ID {taskID} created successfully.");
               }

               logger.LogInformation($"Plugin {this.GetType()} execution successfully completed!");
            }
         }
         catch (InvalidPluginExecutionException pex) 
         {
            logger.LogError(pex.Message, pex);
            throw;
         }
         catch (FaultException<OrganizationServiceFault> fex)
         {
            string message = fex.Detail.Message;
            string finalMessage = $"An error occurred in the {this.GetType().FullName}:{Environment.NewLine}{message}{Environment.NewLine}{fex}";
            logger.LogError(finalMessage, fex);
            throw new InvalidPluginExecutionException(finalMessage, fex);
         }
         catch (Exception ex)
         {
            string finalMessage = $"An error occurred in the {this.GetType().FullName}:{Environment.NewLine}{ex}";
            logger.LogError(finalMessage, ex);
            throw new InvalidPluginExecutionException(finalMessage, ex);
         }
      }
   }
}

exceptions
| order by timestamp
| project timestamp, cloud_RoleInstance, customDimensions["FormattedMessage"], problemId, ['type'], assembly, method, outerType, outerMessage, outerAssembly, outerMethod
| where cloud_RoleInstance contains "SandboxRoleInstance" and method == "JJG.Plugins.AppInsightsSample.Case_OnUpdate_PushAppInsightsSample"

traces
| project timestamp, message, itemType, customDimensions, operation_Id, session_Id
| where operation_Id == "918c491a-ffd6-4820-a432-3c332ed21248_9d7f35ed-376f-49a7-afa5-05bdc3d88ffe"

dependencies
| where type == "Plugin" and name == "JJG.Plugins.AppInsightsSample.Case_OnUpdate_PushAppInsightsSample" and success == false
| project operation_Id, timestamp, target
| join (traces  
        | project operation_Id, message
    ) on $left.operation_Id == $right.operation_Id
| order by timestamp