Azure Durable Functions Part 2: Implementation Patterns & Best Practices

[FunctionName("OrderFulfillmentOrchestrator")] 
public static async Task<string> RunOrderFulfillment([OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 
    var order = context.GetInput<Order>(); 
    
    // Step 1: Process Payment 
    await context.CallActivityAsync("ProcessPayment", order.PaymentDetails); 
 
    // Step 2: Update Inventory 
    await context.CallActivityAsync("UpdateInventory", order.Items);
 
    // Step 3: Ship Order 
    var trackingNumber = await context.CallActivityAsync<string>("ShipOrder", order.ShippingDetails);
 
    return $"Order fulfilled with tracking number: {trackingNumber}"; 
} 

Activity Functions 

[FunctionName("ProcessPayment")] 
public static async Task ProcessPayment([ActivityTrigger] PaymentDetails paymentDetails, ILogger log) 
{ 
    var paymentService = new PaymentService(); 
    await paymentService.ProcessAsync(paymentDetails); 
    log.LogInformation($"Payment processed for amount: {paymentDetails.Amount}"); 
} 
 
[FunctionName("UpdateInventory")] 
public static async Task UpdateInventory([ActivityTrigger] List<OrderItem> items, ILogger log) 
{ 
    var inventoryService = new InventoryService(); 
    await inventoryService.DecrementStockAsync(items); 
    log.LogInformation($"Inventory updated for {items.Count} items"); 
} 

[FunctionName("ShipOrder")] 
public static async Task<string> ShipOrder([ActivityTrigger] ShippingDetails shippingDetails, ILogger log) 
{ 
    var shippingService = new ShippingService(); 
    var trackingNumber = await shippingService.CreateShipmentAsync(shippingDetails); 
    log.LogInformation($"Order shipped with tracking: {trackingNumber}"); 
    return trackingNumber; 
} 

[FunctionName("StartOrderProcessing")] 
public static async Task<IActionResult> HttpStart( 
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req, 
    [DurableClient] IDurableOrchestrationClient starter) 
{ 
    var order = await req.GetJsonAsync<Order>(); 
    string instanceId = await starter.StartNewAsync("OrderFulfillmentOrchestrator", order); 
    return starter.CreateCheckStatusResponse(req, instanceId); 
} 

[FunctionName("ParallelOrderValidationOrchestrator")] 
public static async Task<string> RunParallelValidation([OrchestrationTrigger] IDurableOrchestrationContext context) 

{ 
    var order = context.GetInput<Order>(); 
     
    // Scatter: Start multiple validation tasks in parallel 
    var validationTasks = new List<Task<bool>> 
    { 
        context.CallActivityAsync<bool>("ValidateCustomerCredit", order.CustomerId), 
        context.CallActivityAsync<bool>("CheckInventoryAcrossWarehouses", order.Items), 
        context.CallActivityAsync<bool>("RunFraudDetectionCheck", order.OrderDetails) 

    };      

    // Gather: Wait for all validation tasks to complete 
    var results = await Task.WhenAll(validationTasks);      

    // Process results: Check if all validations passed 
    if (results.All(r => r)) 
    { 
        await context.CallActivityAsync("ApproveOrder", order); 
        return "Order approved"; 
    } 
    else 
    { 
        await context.CallActivityAsync("RejectOrder", order); 
        return "Order rejected due to failed validation"; 
    } 
} 

[FunctionName("ValidateCustomerCredit")] 
public static async Task<bool> ValidateCustomerCredit([ActivityTrigger] string customerId, ILogger log) 
{ 
    var creditService = new CreditCheckService(); 
    var result = await creditService.ValidateAsync(customerId); 
    log.LogInformation($"Credit validation for {customerId}: {result}"); 
    return result; 
} 

[FunctionName("CheckInventoryAcrossWarehouses")] 
public static async Task<bool> CheckInventoryAcrossWarehouses([ActivityTrigger] List<OrderItem> items, ILogger log) 

{ 
    var inventoryService = new InventoryService(); 
    var result = await inventoryService.CheckAvailabilityAcrossWarehousesAsync(items); 
    log.LogInformation($"Inventory check completed: {result}"); 
    return result; 
} 

[FunctionName("RunFraudDetectionCheck")] 
public static async Task<bool> RunFraudDetectionCheck([ActivityTrigger] OrderDetails orderDetails, ILogger log) 

{ 
    var fraudService = new FraudDetectionService(); 
    var result = await fraudService.AnalyzeAsync(orderDetails); 
    log.LogInformation($"Fraud detection completed: {result}"); 
    return result; 
} 

[FunctionName("SubmitLargeOrder")] 
public static async Task<HttpResponseMessage> HttpStart( 
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestMessage req, 
    [DurableClient] IDurableOrchestrationClient starter) 
{ 
    // The request body contains the large order data 
    string requestBody = await req.Content.ReadAsStringAsync(); 
    string instanceId = await starter.StartNewAsync("LargeOrderProcessingOrchestrator", null, requestBody); 
     
    // Return the response with status check URL 
    return starter.CreateCheckStatusResponse(req, instanceId); 
} 

[FunctionName("LargeOrderProcessingOrchestrator")] 
public static async Task<string> ProcessLargeOrder([OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 
    var order = context.GetInput<LargeOrder>(); 
     
    // Process each line item 
    await context.CallActivityAsync("ValidateLargeOrder", order); 
    await context.CallActivityAsync("ProcessPaymentBatch", order); 
    await context.CallActivityAsync("AllocateInventory", order); 
     
    var confirmationNumber = await context.CallActivityAsync<string>("GenerateConfirmation", order);      

    return confirmationNumber; 
} 

{ 
    "id": "d1e7c72e8b9a4c5f9e3d4a2b1c0f8e7d", 
    "statusQueryGetUri": "https://yourapp.azurewebsites.net/runtime/webhooks/durabletask/instances/d1e7c72e8b9a4c5f9e3d4a2b1c0f8e7d?code=...", 
    "sendEventPostUri": "https://yourapp.azurewebsites.net/runtime/webhooks/durabletask/instances/d1e7c72e8b9a4c5f9e3d4a2b1c0f8e7d/raiseEvent/{eventName}?code=...", 
    "terminatePostUri": "https://yourapp.azurewebsites.net/runtime/webhooks/durabletask/instances/d1e7c72e8b9a4c5f9e3d4a2b1c0f8e7d/terminate?reason={text}&code=..." 
} 

[FunctionName("ManualOrderApprovalOrchestrator")] 
public static async Task<string> ProcessOrderApproval( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 

    var order = context.GetInput<Order>(); 
     
    // Auto-approve small orders 
    if (order.Amount < 500) 
    { 
        await context.CallActivityAsync("ProcessOrder", order); 
        return "Auto-approved"; 
    } 
     
    // Send for manager approval 
    await context.CallActivityAsync("SendApprovalRequest", order); 
     
    // Wait for approval or timeout (72 hours) 
    var approvalTask = context.WaitForExternalEvent<bool>("OrderApprovalResponse"); 
    var timeoutTask = context.CreateTimer(context.CurrentUtcDateTime.AddHours(72), CancellationToken.None); 
     
    var completedTask = await Task.WhenAny(approvalTask, timeoutTask); 

    if (completedTask == approvalTask && approvalTask.Result) 
    { 
        await context.CallActivityAsync("ProcessOrder", order); 
        return "Approved"; 
    } 
    else 
    { 
        await context.CallActivityAsync("RejectOrder", order); 
        return "Rejected or Timed Out"; 
    } 
} 

[FunctionName("SendApprovalRequest")] 
public static async Task SendApprovalRequest( 
    [ActivityTrigger] Order order, 
    ILogger log) 
{ 
    var emailService = new EmailService(); 
    await emailService.SendApprovalEmailAsync(order.ManagerEmail, order); 
    log.LogInformation($"Approval request sent for order {order.OrderId}"); 
} 

[FunctionName("ProcessOrder")] 
public static async Task ProcessOrder( 
    [ActivityTrigger] Order order, 
    ILogger log) 
{ 
    var orderService = new OrderService(); 
    await orderService.ProcessAsync(order); 
    log.LogInformation($"Order {order.OrderId} processed successfully"); 
} 
Approval Endpoint 
[FunctionName("SubmitApproval")] 
public static async Task<IActionResult> SubmitApproval( 
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req, 
    [DurableClient] IDurableOrchestrationClient client) 
{ 
    string instanceId = req.Query["instanceId"]; 
    bool approved = bool.Parse(req.Query["approved"]); 
    
    await client.RaiseEventAsync(instanceId, "OrderApprovalResponse", approved); 
     
    return new OkObjectResult($"Approval {(approved ? "granted" : "denied")} for instance {instanceId}"); 
} 

[FunctionName("MultiServiceOrderOrchestrator")] 
public static async Task<string> ProcessOrder( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 

    var order = context.GetInput<Order>(); 
    var compensationActions = new List<string>(); 
     
    try 
    { 
        // Step 1: Reserve Inventory 
        await context.CallActivityAsync("ReserveInventory", order.Items); 
        compensationActions.Add("ReleaseInventory"); 
         
        // Step 2: Process Payment 
        await context.CallActivityAsync("ProcessPayment", order.PaymentDetails); 
        compensationActions.Add("RefundPayment"); 
         
        // Step 3: Update Loyalty Points 
        await context.CallActivityAsync("UpdateLoyaltyPoints", order.CustomerId); 
        compensationActions.Add("RollbackLoyaltyPoints"); 
      
        // All steps succeeded 
        return "Order completed successfully"; 
    } 
    catch (Exception) 
    { 
        // Compensate in reverse order 
        compensationActions.Reverse(); 
        foreach (var action in compensationActions) 
        { 
            await context.CallActivityAsync(action, order); 
        } 
         
        return "Order failed and rolled back."; 
    } 
} 

[FunctionName("ReserveInventory")] 
public static async Task ReserveInventory([ActivityTrigger] List<OrderItem> items, ILogger log) 
{ 
    var inventoryService = new InventoryService(); 
    await inventoryService.ReserveAsync(items); 
    log.LogInformation("Inventory reserved"); 
} 

[FunctionName("ReleaseInventory")] 
public static async Task ReleaseInventory([ActivityTrigger] Order order, ILogger log) 
{ 
    var inventoryService = new InventoryService(); 
    await inventoryService.ReleaseAsync(order.Items); 
    log.LogInformation("Inventory released (compensation)"); 
} 

[FunctionName("ProcessPayment")] 
public static async Task ProcessPayment([ActivityTrigger] PaymentDetails paymentDetails, ILogger log) 
{ 
    var paymentService = new PaymentService(); 
    await paymentService.ChargeAsync(paymentDetails); 
    log.LogInformation("Payment processed"); 
} 

[FunctionName("RefundPayment")] 
public static async Task RefundPayment([ActivityTrigger] Order order, ILogger log) 
{ 
    var paymentService = new PaymentService(); 
    await paymentService.RefundAsync(order.PaymentDetails); 
    log.LogInformation("Payment refunded (compensation)"); 
} 

[FunctionName("UpdateLoyaltyPoints")] 
public static async Task UpdateLoyaltyPoints([ActivityTrigger] string customerId, ILogger log) 
{ 
    var loyaltyService = new LoyaltyService(); 
    await loyaltyService.AddPointsAsync(customerId, 100); 
    log.LogInformation("Loyalty points updated"); 
} 

[FunctionName("RollbackLoyaltyPoints")] 
public static async Task RollbackLoyaltyPoints([ActivityTrigger] Order order, ILogger log) 
{ 
    var loyaltyService = new LoyaltyService(); 
    await loyaltyService.RemovePointsAsync(order.CustomerId, 100); 
    log.LogInformation("Loyalty points rolled back (compensation)"); 
} 

[FunctionName("CustomerOnboardingOrchestrator")] 
public static async Task<string> ProcessCustomerOnboarding( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 
    var customer = context.GetInput<Customer>(); 
     
    // Start initial tasks 
    await context.CallActivityAsync("CreateCustomerAccount", customer); 
    await context.CallActivityAsync("SendWelcomeEmail", customer); 
     
    // Wait for external event (CreditCheckResult) 
    var creditCheckResult = await context.WaitForExternalEvent<bool>("CreditCheckResult"); 
     
    if (creditCheckResult) 
    { 
        await context.CallActivityAsync("ActivatePremiumFeatures", customer); 
        await context.CallActivityAsync("SendActivationEmail", customer); 
        return "Customer onboarded successfully"; 
    } 
    else 
    { 
        await context.CallActivityAsync("RejectCustomer", customer); 
        return "Customer onboarding rejected due to failed credit check"; 
    } 
} 

Activity Functions 

[FunctionName("CreateCustomerAccount")] 
public static async Task CreateCustomerAccount( 
    [ActivityTrigger] Customer customer, 
    ILogger log) 
{ 
    var customerService = new CustomerService(); 
    await customerService.CreateAccountAsync(customer); 
    log.LogInformation($"Customer account created: {customer.CustomerId}"); 
} 

[FunctionName("SendWelcomeEmail")] 
public static async Task SendWelcomeEmail( 
    [ActivityTrigger] Customer customer, 
    ILogger log) 
{ 
    var emailService = new EmailService(); 
    await emailService.SendWelcomeAsync(customer.Email); 
    log.LogInformation($"Welcome email sent to: {customer.Email}"); 
} 

[FunctionName("ActivatePremiumFeatures")] 
public static async Task ActivatePremiumFeatures( 
    [ActivityTrigger] Customer customer, 
    ILogger log) 
{ 
    var customerService = new CustomerService(); 
    await customerService.ActivatePremiumAsync(customer.CustomerId); 
    log.LogInformation($"Premium features activated for: {customer.CustomerId}"); 
}

External Event Trigger (Credit Check Callback) 

[FunctionName("CreditCheckCallback")] 
public static async Task<IActionResult> ReceiveCreditCheckResult( 
    [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequest req, 
    [DurableClient] IDurableOrchestrationClient client) 
{ 
    string instanceId = req.Query["instanceId"]; 
    var creditCheckResult = await req.GetJsonAsync<CreditCheckResult>(); 
     
    await client.RaiseEventAsync(instanceId, "CreditCheckResult", creditCheckResult.Passed); 
     
    return new OkObjectResult($"Credit check result received for instance {instanceId}"); 
} 

[FunctionName("ResilientOrderOrchestrator")] 
public static async Task<string> ProcessOrder( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 
    var order = context.GetInput<Order>(); 
     
    // Configure retry policy for inventory validation 
    var retryOptions = new RetryOptions( 
        firstRetryInterval: TimeSpan.FromSeconds(5), 
        maxNumberOfAttempts: 3); 
    
    var inventoryResult = await context.CallActivityWithRetryAsync<bool>("ValidateInventory", retryOptions, order.ProductId); 
     
    if (!inventoryResult) 
        return "Order failed: Insufficient inventory"; 
     
    // Process payment with different retry strategy 
    var paymentRetryOptions = new RetryOptions( 
        firstRetryInterval: TimeSpan.FromSeconds(5), 
        maxNumberOfAttempts: 5) 
    { 
        BackoffCoefficient = 2.0, 
        MaxRetryInterval = TimeSpan.FromMinutes(5) 
    }; 
     
    var paymentResult = await context.CallActivityWithRetryAsync<PaymentResult>("ProcessPayment", paymentRetryOptions, order); 
     
    if (!paymentResult.Success) 
        return "Order failed: Payment declined"; 
     
    await context.CallActivityAsync("ShipOrder", order); 
     
    return "Order processed successfully"; 
} 

[FunctionName("ProcessPayment")] 
public static async Task<PaymentResult> ProcessPayment([ActivityTrigger] PaymentRequest request, ILogger log) 
{ 
    try 
    { 
        var paymentGateway = new PaymentGatewayService(); 
        return await paymentGateway.ProcessAsync(request); 
    } 
    catch (RateLimitException ex) 
    { 
        log.LogWarning($"Rate limit hit: {ex.Message}"); 
        // Wait before retry 
        await Task.Delay(TimeSpan.FromMinutes(1)); 
        throw; // This will trigger the retry with backoff 
    } 
    catch (PaymentDeclinedException ex) 
    { 
        log.LogInformation($"Payment declined: {ex.Message}"); 
        // Don't retry declined payments 
        return new PaymentResult  
        {  
            Success = false,  
            Reason = ex.Message  
        }; 
    } 
    catch (PaymentGatewayException ex) 
    { 
        log.LogError($"Payment gateway error: {ex.Message}"); 
        throw; // Retry for transient gateway errors 
    } 
} 

The example above shows:

• Catch and classify exceptions to control retry behaviour.

• Throw exceptions for transient issues (to trigger retry); return handled results for permanent ones.

• Combine with CallActivityWithRetryAsync() for robust, layered fault tolerance.

[FunctionName("ComplexPricingOrchestrator")] 
public static async Task<PricingResult> CalculateOrderPrice( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 
    var order = context.GetInput<Order>(); 
   
    // Get customer details 
    var customer = await context.CallActivityAsync<Customer>("GetCustomer", order.CustomerId); 
     
    // Get current season and regional data in parallel 
    var seasonTask = context.CallActivityAsync<Season>("GetCurrentSeason", null); 
    var regionTask = context.CallActivityAsync<Region>("GetRegion", customer.RegionId); 
     
    await Task.WhenAll(seasonTask, regionTask); 
     
    var season = seasonTask.Result; 
    var region = regionTask.Result; 
     
    // Calculate base pricing 
    var pricing = await context.CallActivityAsync<PricingResult>( 
        "CalculatePricing",  
        new PricingInput { Order = order, Customer = customer, Season = season, Region = region }); 
     
    // Apply VIP discount if eligible 
    if (customer.IsVIP && order.Amount > 10000) 
    { 
        pricing = await context.CallActivityAsync<PricingResult>( 
            "ApplyVIPDiscount",  
            new DiscountInput { Pricing = pricing, LoyaltyTier = customer.LoyaltyTier }); 
    } 
     
    // Apply bulk discount 
    if (order.Items.Sum(i => i.Quantity) > 100) 
    { 
        pricing = await context.CallActivityAsync<PricingResult>( 
            "ApplyBulkDiscount", 
            pricing); 
    } 
     
    // Apply seasonal promotion if active 
    if (season.HasPromotion) 
    { 
        pricing = await context.CallActivityAsync<PricingResult>( 
            "ApplySeasonalPromotion", 
            new PromotionInput { Pricing = pricing, Season = season }); 
    } 
     
    return pricing; 
} 

• Demonstrates complex orchestration logic combining parallelism (Task.WhenAll) and branching. 

• Each discount or rule is modulariszed as an activity improving maintainability and testability. 

• This kind of dynamic, multi-criteria pricing is hard to express in Logic Apps, but natural in code. 

// DON'T DO THIS 
public static async Task BadOrchestrator( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 
    // Non-deterministic operations 
    var random = new Random().Next(); //Don't use Random 
    var now = DateTime.Now; // Don't use DateTime.Now 
    var guid = Guid.NewGuid(); // Don't generate GUIDs 
     
    // I/O operations 
    await File.ReadAllTextAsync("file.txt"); // No direct I/O 
    await httpClient.GetAsync("https://api.example.com"); // No direct HTTP calls 
} 

Do Instead:

// DO THIS 
public static async Task GoodOrchestrator( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 

{ 
    // Use context methods for deterministic behaviour 
    var currentTime = context.CurrentUtcDateTime; // set context time 
    var guid = context.NewGuid(); // Use context GUID 
     
    // Put all I/O in activity functions 
    var fileContent = await context.CallActivityAsync<string>("ReadFile", "file.txt"); 
    var apiResult = await context.CallActivityAsync<string>("CallExternalApi", "https://api.example.com"); 
} 

2. Design Activity Functions for Idempotency

Activity functions may be executed multiple times due to retries. Design them to be idempotent – safe to execute multiple times with the same input.

[FunctionName("UpdateInventoryIdempotent")] 
public static async Task UpdateInventory([ActivityTrigger] InventoryUpdate update, ILogger log) 
{ 
    var inventoryService = new InventoryService(); 
     
    // Check if this update was already applied 
    var existingUpdate = await inventoryService.GetUpdateByIdAsync(update.UpdateId); 
     
    if (existingUpdate != null) 
    { 
        log.LogInformation($"Update {update.UpdateId} already applied, skipping"); 
        return; 
    } 
     
    // Apply the update and record it 
    await inventoryService.ApplyUpdateAsync(update); 
    log.LogInformation($"Inventory updated: {update.UpdateId}"); 
} 

3. Use Unique Task Hubs for each Application

Separate different applications or environments using unique Task Hub names to prevent interference.

{ 
  "extensions": { 
    "durableTask": { 
      "hubName": "OrderProcessing" 
    } 
  } 
} 

4. Implement Comprehensive Monitoring

Configure Application Insights for complete observability:

[FunctionName("MonitoredOrchestrator")] 
public static async Task<string> ProcessOrder([OrchestrationTrigger] IDurableOrchestrationContext context, ILogger log) 
{ 
    var order = context.GetInput<Order>(); 
     
    // Log at key points 
    log.LogInformation($"Starting order processing for {order.OrderId}"); 
     
    try 
    { 
        await context.CallActivityAsync("ProcessPayment", order); 
        log.LogInformation($"Payment processed for order {order.OrderId}"); 
         
        await context.CallActivityAsync("ShipOrder", order); 
        log.LogInformation($"Order {order.OrderId} shipped successfully"); 
         
        return "Success"; 
    } 
    catch (Exception ex) 
    { 
        log.LogError(ex, $"Order {order.OrderId} failed: {ex.Message}"); 
        throw; 
    } 
} 

5. Handle Long-running Workflows with Checkpoints

For very long-running workflows, use sub-orchestrations to break down the process:

[FunctionName("LongRunningOrderOrchestrator")] 
public static async Task<string> ProcessLongRunningOrder( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 
    var order = context.GetInput<Order>(); 
    
    // Phase 1: Order Validation (sub-orchestration) 
    await context.CallSubOrchestratorAsync("OrderValidationOrchestrator", order); 
     
    // Phase 2: Payment Processing (sub-orchestration) 
    await context.CallSubOrchestratorAsync("PaymentProcessingOrchestrator", order); 
     
    // Phase 3: Fulfillment (sub-orchestration) 
    await context.CallSubOrchestratorAsync("FulfillmentOrchestrator", order); 
     
    return "Order completed through all phases"; 
} 

6. Implement Proper Error Recovery

[FunctionName("RobustOrchestrator")] 
public static async Task<string> ProcessWithRecovery( 
    [OrchestrationTrigger] IDurableOrchestrationContext context) 
{ 
    var order = context.GetInput<Order>(); 
    var maxAttempts = 3; 
     
    for (int attempt = 1; attempt <= maxAttempts; attempt++) 
    { 
        try 
        { 
            await context.CallActivityAsync("ProcessOrder", order); 
            return "Success"; 
        } 
        catch (Exception ex) when (attempt < maxAttempts) 
        { 
            // Log and wait before retry 
            await context.CallActivityAsync("LogError",  
                new ErrorLog { OrderId = order.OrderId, Attempt = attempt, Error = ex.Message }); 
             
            // Exponential backoff 
            var delay = TimeSpan.FromSeconds(Math.Pow(2, attempt)); 
            await context.CreateTimer(context.CurrentUtcDateTime.Add(delay), CancellationToken.None); 
        } 
    } 
     
    // All attempts failed 
    await context.CallActivityAsync("NotifyFailure", order); 
    return "Failed after all retry attempts"; 
} 

8. Monitoring and Observability

Azure provides comprehensive monitoring capabilities for Durable Functions through Azure Monitor and Application Insights, allowing you to gain end-to-end visibility into orchestration health, performance, and reliability.

Just like standard Azure Functions, all log entries, metrics, and exceptions from Durable Functions automatically flow into Application Insights when the SDK is configured. However, Durable Functions introduce additional telemetry dimensions because of their orchestration model. Every orchestration, activity, and event becomes its own tracked operation with a shared correlation ID.

How Durable Functions Appear in Application Insights:

• Orchestration as Request Telemetry: Each orchestration instance (triggered by [OrchestrationTrigger]) is recorded as a “request” in Application Insights.

• The operation_Id uniquely identifies the orchestration instance.

• The operation_ParentId links activity executions back to the orchestrator, allowing you to view a full dependency tree.

• Activities as Dependency Telemetry: Each call to CallActivityAsync or CallSubOrchestratorAsync appears as a dependency under the parent orchestration.

• Custom metrics logged via log.LogMetric(…) appear in the Custom Metrics blade or in KQL as customMetrics.

This structure makes it easy to trace a specific instance, such as an individual order, from orchestration start to completion.

public class Startup : FunctionsStartup 
{ 
    public override void Configure(IFunctionsHostBuilder builder) 
    { 
        builder.Services.AddApplicationInsightsTelemetry(); 
         
        // Add custom telemetry initializer 
        builder.Services.AddSingleton<ITelemetryInitializer, CustomTelemetryInitializer>(); 
    } 
} 

[FunctionName("OrderProcessingWithMetrics")] 
public static async Task<string> ProcessOrder( 
    [OrchestrationTrigger] IDurableOrchestrationContext context, 
    ILogger log) 
{ 
    var order = context.GetInput<Order>(); 
    var stopwatch = Stopwatch.StartNew(); 
   
    try 
    { 
        await context.CallActivityAsync("ProcessPayment", order); 
        await context.CallActivityAsync("ShipOrder", order); 
         
        stopwatch.Stop(); 
         
        // Track custom metric 
        log.LogMetric("OrderProcessingTime", stopwatch.ElapsedMilliseconds,  
            new Dictionary<string, object> 
            { 
                { "OrderId", order.OrderId }, 
                { "OrderAmount", order.Amount }, 
                { "Success", true } 
            }); 
         
        return "Success"; 
    } 
    catch (Exception ex) 
    { 
        stopwatch.Stop(); 
         
        log.LogMetric("OrderProcessingTime", stopwatch.ElapsedMilliseconds, 
            new Dictionary<string, object> 
            { 
                { "OrderId", order.OrderId }, 
                { "Success", false }, 
                { "ErrorType", ex.GetType().Name } 
            }); 
         
        throw; 
    } 
} 

traces 
| where customDimensions["DurableInstanceId"] == "abc123" 

Alternatively, if you’re using Durable Functions Monitor or Azure Portal → Functions → Monitor, you can search by instance ID to view orchestration status, history, and failure details without writing KQL.

You can visualise orchestrations using:

• Application Insights Transaction Search: Displays full call chains (orchestrator → activities → dependencies → logs).

• Azure Monitor Workbooks: Use a workbook to combine metrics such as orchestration duration, failure rate, and custom metrics like OrderProcessingTime. Workbooks are ideal for creating a central observability dashboard.

• Durable Functions Monitor (open source): A dedicated viewer that provides instance history, inputs, outputs, and replays directly from storage or App Insights. Reference: https://github.com/microsoft/DurableFunctionsMonitor

• Monitoring Dashboard (preview): Observe, manage, and debug your task hub or scheduler’s orchestrations using the Durable Task Scheduler dashboard. Reference: https://learn.microsoft.com/en-us/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler-dashboard?pivots=az-cli

requests 
| where cloud_RoleName == "your-function-app" 
| where name == "ProcessOrder" 
| summarize avg(duration) by bin(timestamp, 1h) 

exceptions 
| where cloud_RoleName == "your-function-app" 
| summarize count() by type 

customMetrics 
| where name == "OrderProcessingTime" 
| summarize avg(value) by tostring(customDimensions["Success"]), bin(timestamp, 1h) 

Built-in vs Custom Monitoring:

• Out of the box:

• • Application Insights automatically collects request, dependency, trace, and exception telemetry.

• • The Azure Portal Durable Functions Monitoring tab provides basic instance-level insights.

• Custom Workbooks or Dashboards:

• • For production-grade systems (e.g., order tracking, SLAs, or tenant-level analytics), custom Azure Workbooks or Power BI dashboards are recommended.

• • They let you correlate business-level metrics (e.g., Order ID, Amount, Duration) with operational telemetry for proactive monitoring and alerting.

{ 
  "version": "2.0", 
  "extensions": { 
    "durableTask": { 
      "storageProvider": { 
        "maxHistoryEntryAge": "30.00:00:00" 
      } 
    } 
  } 
} 

• maxHistoryEntryAge: Specifies the retention time window in the D.HH:MM:SS format. A value of “30.00:00:00” ensures that the historical records are deleted 30 days after the orchestration completes. 

Note: For more advanced retention policies, especially when using the new Durable Task Scheduler (which provides specific purge rules for Completed, Failed, and Canceled statuses – this is in preview currently), refer to the official documentation: https://learn.microsoft.com/en-us/azure/azure-functions/durable/durable-task-scheduler/durable-task-scheduler-auto-purge?tabs=cli