Obsługa błędów w rozszerzeniu Durable Functions (Azure Functions)

Orkiestracje funkcji durable są implementowane w kodzie i mogą korzystać z wbudowanych funkcji obsługi błędów języka programowania. Naprawdę nie ma żadnych nowych pojęć, których musisz nauczyć się dodawać do aranżacji obsługę błędów i rekompensatę. Istnieje jednak kilka zachowań, o których należy pamiętać.

Uwaga

Wersja 4 modelu programowania Node.js dla usługi Azure Functions jest ogólnie dostępna. Nowy model w wersji 4 został zaprojektowany z myślą o bardziej elastycznym i intuicyjnym środowisku dla deweloperów języków JavaScript i TypeScript. Dowiedz się więcej o różnicach między wersjami 3 i v4 w przewodniku migracji.

W poniższych fragmentach kodu javaScript (PM4) oznacza model programowania W wersji 4, nowe środowisko.

Błędy w funkcjach aktywności i podorchiestracjach

W usłudze Durable Functions nieobsługiwane wyjątki zgłaszane w ramach funkcji działań lub podaranżacji są marshalingowane z powrotem do funkcji orkiestratora przy użyciu ustandaryzowanych typów wyjątków.

Rozważmy na przykład następującą funkcję orkiestratora, która wykonuje transfer środków między dwoma kontami:

C# (InProc)

W Durable Functions C# nieobsługiwane wyjątki są zgłaszane jako FunctionFailedException.

Komunikat o wyjątku zazwyczaj identyfikuje, które funkcje działania lub pod-orchestracje spowodowały awarię. Aby uzyskać dostęp do bardziej szczegółowych informacji o błędach, sprawdź właściwość InnerException.

[FunctionName("TransferFunds")]
public static async Task Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var transferDetails = context.GetInput<TransferOperation>();

    await context.CallActivityAsync("DebitAccount",
        new
        {
            Account = transferDetails.SourceAccount,
            Amount = transferDetails.Amount
        });

    try
    {
        await context.CallActivityAsync("CreditAccount",
            new
            {
                Account = transferDetails.DestinationAccount,
                Amount = transferDetails.Amount
            });
    }
    catch (FunctionFailedException)
    {
        // Refund the source account.
        // Another try/catch could be used here based on the needs of the application.
        await context.CallActivityAsync("CreditAccount",
            new
            {
                Account = transferDetails.SourceAccount,
                Amount = transferDetails.Amount
            });
    }
}

Uwaga

Poprzednie przykłady języka C# dotyczą rozszerzenia Durable Functions 2.x. W przypadku rozszerzenia Durable Functions 1.x należy użyć funkcji DurableOrchestrationContextIDurableOrchestrationContextzamiast . Aby uzyskać więcej informacji na temat różnic między wersjami, zobacz artykuł Wersje rozszerzenia Durable Functions.

C# (izolowane)

W funkcji Durable Functions w języku C# Izolowane nieobsługiwane wyjątki są wyświetlane jako TaskFailedException.

Komunikat o wyjątku zazwyczaj identyfikuje, które funkcje działania lub podarancje spowodowały awarię. Aby uzyskać dostęp do bardziej szczegółowych informacji o błędach, sprawdź właściwość FailureDetails .

[FunctionName("TransferFunds")]
public static async Task Run(
    [OrchestrationTrigger] TaskOrchestrationContext context, TransferOperation transferDetails)
{
    await context.CallActivityAsync("DebitAccount",
        new
        {
            Account = transferDetails.SourceAccount,
            Amount = transferDetails.Amount
        });

    try
    {
        await context.CallActivityAsync("CreditAccount",
            new
            {
                Account = transferDetails.DestinationAccount,
                Amount = transferDetails.Amount
            });
    }
    catch (TaskFailedException)
    {
        // Refund the source account.
        // Another try/catch could be used here based on the needs of the application.
        await context.CallActivityAsync("CreditAccount",
            new
            {
                Account = transferDetails.SourceAccount,
                Amount = transferDetails.Amount
            });
    }
}

Uwaga

• Komunikat o wyjątku zazwyczaj identyfikuje, które funkcje działania lub podarancje spowodowały awarię. Aby uzyskać dostęp do bardziej szczegółowych informacji o błędach, sprawdź właściwość FailureDetails.
• Domyślnie FailureDetails zawiera typ błędu, komunikat o błędzie, ślad stosu oraz wszystkie zagnieżdżone wyjątki wewnętrzne (każdy reprezentowany jako rekursywny obiekt FailureDetails). Jeśli chcesz uwzględnić dodatkowe właściwości wyjątku w danych wyjściowych błędu, zobacz Include Custom Exception Properties for FailureDetails (.NET Isolated).

JavaScript (PM3)

const df = require("durable-functions");

module.exports = df.orchestrator(function* (context) {
    const transferDetails = context.df.getInput();

    yield context.df.callActivity("DebitAccount", {
        account: transferDetails.sourceAccount,
        amount: transferDetails.amount,
    });

    try {
        yield context.df.callActivity("CreditAccount", {
            account: transferDetails.destinationAccount,
            amount: transferDetails.amount,
        });
    } catch (error) {
        // Refund the source account.
        // Another try/catch could be used here based on the needs of the application.
        yield context.df.callActivity("CreditAccount", {
            account: transferDetails.sourceAccount,
            amount: transferDetails.amount,
        });
    }
})

JavaScript (PM4)

const df = require("durable-functions");

df.app.orchestration("transferFunds", function* (context) {
    const transferDetails = context.df.getInput();

    yield context.df.callActivity("debitAccount", {
        account: transferDetails.sourceAccount,
        amount: transferDetails.amount,
    });

    try {
        yield context.df.callActivity("creditAccount", {
            account: transferDetails.destinationAccount,
            amount: transferDetails.amount,
        });
    } catch (error) {
        // Refund the source account.
        // Another try/catch could be used here based on the needs of the application.
        yield context.df.callActivity("creditAccount", {
            account: transferDetails.sourceAccount,
            amount: transferDetails.amount,
        });
    }
});

Python

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    transfer_details = context.get_input()

    yield context.call_activity('DebitAccount', {
         'account': transfer_details['sourceAccount'],
         'amount' : transfer_details['amount']
    })

    try:
        yield context.call_activity('CreditAccount', {
                'account': transfer_details['destinationAccount'],
                'amount': transfer_details['amount'],
            })
    except:
        yield context.call_activity('CreditAccount', {
            'account': transfer_details['sourceAccount'],
            'amount': transfer_details['amount']
        })

main = df.Orchestrator.create(orchestrator_function)

Program PowerShell

Domyślnie polecenia cmdlet w programie PowerShell nie zgłaszają wyjątków, które można przechwycić przy użyciu bloków try/catch. Dostępne są dwie opcje zmiany tego zachowania:

1. Użyj flagi -ErrorAction Stop podczas wywoływania poleceń cmdlet, takich jak Invoke-DurableActivity.
2. Ustaw zmienną preferencji $ErrorActionPreference na "Stop" w funkcji orkiestratora przed wywołaniem poleceń cmdlet.

param($Context)

$ErrorActionPreference = "Stop"

$transferDetails = $Context.Input

Invoke-DurableActivity -FunctionName 'DebitAccount' -Input @{ account = transferDetails.sourceAccount; amount = transferDetails.amount }

try {
    Invoke-DurableActivity -FunctionName 'CreditAccount' -Input @{ account = transferDetails.destinationAccount; amount = transferDetails.amount }
} catch {
    Invoke-DurableActivity -FunctionName 'CreditAccount' -Input @{ account = transferDetails.sourceAccount; amount = transferDetails.amount }
}

Aby uzyskać więcej informacji na temat obsługi błędów w programie PowerShell, zobacz dokumentację programu PowerShell Try-Catch-Finally .

Java

@FunctionName("TransferFunds")
public void transferFunds(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    TransferOperation transfer = ctx.getInput(TransferOperation.class);
    ctx.callActivity(
        "DebitAccount", 
        new OperationArgs(transfer.sourceAccount, transfer.amount)).await();
    try {
        ctx.callActivity(
            "CreditAccount", 
            new OperationArgs(transfer.destinationAccount, transfer.amount)).await();
    } catch (TaskFailedException ex) {
        // Refund the source account on failure
        ctx.callActivity(
            "CreditAccount", 
            new OperationArgs(transfer.sourceAccount, transfer.amount)).await();
    }
}

Jeśli pierwsze wywołanie funkcji CreditAccount zakończy się niepowodzeniem, funkcja orkiestratora kompensuje środki z powrotem do konta źródłowego.

Błędy w funkcjach jednostki

Zachowanie obsługi wyjątków dla funkcji jednostek różni się w zależności od modelu hostingu Durable Functions.

C# (InProc)

W usłudze Durable Functions przy użyciu języka C# w procesie oryginalne typy wyjątków zgłaszane przez funkcje jednostek są bezpośrednio zwracane do orkiestratora.

[FunctionName("Function1")]
public static async Task<string> RunOrchestrator(
    [OrchestrationTrigger] IDurableOrchestrationContext context)
{
    try
    {
        var entityId = new EntityId(nameof(Counter), "myCounter");
        await context.CallEntityAsync(entityId, "Add", 1);
    }
    catch (Exception ex)
    {
        // The exception type will be InvalidOperationException with the message "this is an entity exception".
    }
    return string.Empty;
}

[FunctionName("Counter")]
public static void Counter([EntityTrigger] IDurableEntityContext ctx)
{
    switch (ctx.OperationName.ToLowerInvariant())
    {
        case "add":
            throw new InvalidOperationException("this is an entity exception");
        case "get":
            ctx.Return(ctx.GetState<int>());
            break;
    }
}

C# (izolowane)

W trybie izolowanym Durable Functions dla języka C#, wyjątki są przekazywane do orkiestratora jako element EntityOperationFailedException. Aby uzyskać dostęp do oryginalnych szczegółów wyjątku, sprawdź jego FailureDetails właściwość.

[Function(nameof(MyOrchestrator))]
public static async Task<List<string>> MyOrchestrator(
   [Microsoft.Azure.Functions.Worker.OrchestrationTrigger] TaskOrchestrationContext context)
{
    var entityId = new Microsoft.DurableTask.Entities.EntityInstanceId(nameof(Counter), "myCounter");
    try
    {
        await context.Entities.CallEntityAsync(entityId, "Add", 1);
    }
    catch (EntityOperationFailedException ex)
    {
        // Add your error handling
    }

    return new List<string>();
}

JavaScript (PM3)

df.app.orchestration("counterOrchestration", function* (context) {
    const entityId = new df.EntityId(counterEntityName, "myCounter");

    try {
        const currentValue = yield context.df.callEntity(entityId, "get");
        if (currentValue < 10) {
            yield context.df.callEntity(entityId, "add", 1);
        }
    } catch (err) {
        context.log(`Entity call failed: ${err.message ?? err}`);
    }
});

JavaScript (PM4)

df.app.orchestration("counterOrchestration", function* (context) {
    const entityId = new df.EntityId(counterEntityName, "myCounter");

    try {
        const currentValue = yield context.df.callEntity(entityId, "get");
        if (currentValue < 10) {
            yield context.df.callEntity(entityId, "add", 1);
        }
    } catch (err) {
        context.log(`Entity call failed: ${err.message ?? err}`);
    }
});

Python

@myApp.orchestration_trigger(context_name="context")
def run_orchestrator(context):
    try:
        entityId = df.EntityId("Counter", "myCounter")
        yield context.call_entity(entityId, "get")
        return "finished"
    except Exception as e:
        # Add your error handling

Program PowerShell

Funkcje jednostek nie są obecnie obsługiwane w programie PowerShell.

Java

Funkcje jednostek nie są obecnie obsługiwane w języku Java.

Automatyczne ponawianie próby po awarii

Podczas wywoływania funkcji działań lub funkcji aranżacji podrzędnej można określić zasady automatycznego ponawiania. Poniższy przykład próbuje wywołać funkcję maksymalnie trzy razy i czeka 5 sekund między kolejnymi próbami:

C# (InProc)

[FunctionName("TimerOrchestratorWithRetry")]
public static async Task Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var retryOptions = new RetryOptions(
        firstRetryInterval: TimeSpan.FromSeconds(5),
        maxNumberOfAttempts: 3);

    await context.CallActivityWithRetryAsync("FlakyFunction", retryOptions, null);

    // ...
}

Uwaga

Poprzednie przykłady języka C# dotyczą rozszerzenia Durable Functions 2.x. W przypadku rozszerzenia Durable Functions 1.x należy użyć funkcji DurableOrchestrationContextIDurableOrchestrationContextzamiast . Aby uzyskać więcej informacji na temat różnic między wersjami, zobacz artykuł Wersje rozszerzenia Durable Functions.

C# (izolowane)

[FunctionName("TimerOrchestratorWithRetry")]
public static async Task Run([OrchestrationTrigger] TaskOrchestrationContext context)
{
    var options = TaskOptions.FromRetryPolicy(new RetryPolicy(
        maxNumberOfAttempts: 3,
        firstRetryInterval: TimeSpan.FromSeconds(5)));

    await context.CallActivityAsync("FlakyFunction", options: options);

    // ...
}

JavaScript (PM3)

const df = require("durable-functions");

module.exports = df.orchestrator(function*(context) {
    const firstRetryIntervalInMilliseconds = 5000;
    const maxNumberOfAttempts = 3;

    const retryOptions = 
        new df.RetryOptions(firstRetryIntervalInMilliseconds, maxNumberOfAttempts);

    yield context.df.callActivityWithRetry("FlakyFunction", retryOptions);

    // ...
});

JavaScript (PM4)

const df = require("durable-functions");

df.app.orchestration("callActivityWithRetry", function* (context) {
    const firstRetryIntervalInMilliseconds = 5000;
    const maxNumberOfAttempts = 3;

    const retryOptions = new df.RetryOptions(firstRetryIntervalInMilliseconds, maxNumberOfAttempts);

    yield context.df.callActivityWithRetry("flakyFunction", retryOptions);

    // ...
});

Python

import azure.functions as func
import azure.durable_functions as df

def orchestrator_function(context: df.DurableOrchestrationContext):
    first_retry_interval_in_milliseconds = 5000
    max_number_of_attempts = 3

    retry_options = df.RetryOptions(first_retry_interval_in_milliseconds, max_number_of_attempts)

    yield context.call_activity_with_retry('FlakyFunction', retry_options)

main = df.Orchestrator.create(orchestrator_function)

Program PowerShell

param($Context)

$retryOptions = New-DurableRetryOptions `
                    -FirstRetryInterval (New-TimeSpan -Seconds 5) `
                    -MaxNumberOfAttempts 3

Invoke-DurableActivity -FunctionName 'FlakyFunction' -RetryOptions $retryOptions

Java

@FunctionName("TimerOrchestratorWithRetry")
public void timerOrchestratorWithRetry(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    final int maxAttempts = 3;
    final Duration firstRetryInterval = Duration.ofSeconds(5);
    RetryPolicy policy = new RetryPolicy(maxAttempts, firstRetryInterval);
    TaskOptions options = new TaskOptions(policy);
    ctx.callActivity("FlakeyFunction", options).await();
    // ...
}

Wywołanie funkcji działania w poprzednim przykładzie przyjmuje parametr do konfigurowania zasad automatycznego ponawiania. Istnieje kilka opcji dostosowywania zasad automatycznego ponawiania prób:

• Maksymalna liczba prób: maksymalna liczba prób. Jeśli zostanie ustawiona wartość 1, nie będzie ponawiania próby.
• Interwał ponawiania prób: czas oczekiwania przed pierwszą próbą ponawiania próby.
• Współczynnik wycofywania: współczynnik używany do określania współczynnika wzrostu wycofywania. Wartość domyślna to 1.
• Maksymalny interwał ponawiania prób: maksymalny czas oczekiwania między ponownymi próbami.
• Limit czasu ponawiania prób: maksymalna ilość czasu na ponawianie prób. Domyślne zachowanie polega na ponawianiu próby przez czas nieokreślony.

Niestandardowe programy obsługi ponawiania prób

W przypadku korzystania z platformy .NET lub Języka Java możesz również zaimplementować programy obsługi ponawiania prób w kodzie. Jest to przydatne, gdy zasady ponawiania deklaratywnego nie są wystarczająco wyraziste. W przypadku języków, które nie obsługują niestandardowych procedur obsługi ponawiania prób, nadal istnieje możliwość implementowania zasad ponawiania przy użyciu pętli, obsługi wyjątków i czasomierzy w celu wstrzykiwania opóźnień między ponownymi próbami.

C# (InProc)

RetryOptions retryOptions = new RetryOptions(
    firstRetryInterval: TimeSpan.FromSeconds(5),
    maxNumberOfAttempts: int.MaxValue)
    {
        Handle = exception =>
        {
            // True to handle and try again, false to not handle and throw.
            if (exception is TaskFailedException failure)
            {
                // Exceptions from TaskActivities are always this type. Inspect the
                // inner Exception to get more details.
            }

            return false;
        };
    }

await ctx.CallActivityWithRetryAsync("FlakeyActivity", retryOptions, null);

C# (izolowane)

TaskOptions retryOptions = TaskOptions.FromRetryHandler(retryContext =>
{
    // Don't retry anything that derives from ApplicationException
    if (retryContext.LastFailure.IsCausedBy<ApplicationException>())
    {
        return false;
    }

    // Quit after N attempts
    return retryContext.LastAttemptNumber < 3;
});

try
{
    await ctx.CallActivityAsync("FlakeyActivity", options: retryOptions);
}
catch (TaskFailedException)
{
    // Case when the retry handler returns false...
}

JavaScript (PM3)

Język JavaScript nie obsługuje obecnie niestandardowych procedur obsługi ponawiania prób. Nadal jednak istnieje możliwość zaimplementowania logiki ponawiania prób bezpośrednio w funkcji orkiestratora przy użyciu pętli, obsługi wyjątków i czasomierzy w celu wstrzykiwania opóźnień między ponownymi próbami.

JavaScript (PM4)

Język JavaScript nie obsługuje obecnie niestandardowych procedur obsługi ponawiania prób. Nadal jednak istnieje możliwość zaimplementowania logiki ponawiania prób bezpośrednio w funkcji orkiestratora przy użyciu pętli, obsługi wyjątków i czasomierzy w celu wstrzykiwania opóźnień między ponownymi próbami.

Python

Język Python nie obsługuje obecnie niestandardowych procedur obsługi ponawiania prób. Nadal jednak istnieje możliwość zaimplementowania logiki ponawiania prób bezpośrednio w funkcji orkiestratora przy użyciu pętli, obsługi wyjątków i czasomierzy w celu wstrzykiwania opóźnień między ponownymi próbami.

Program PowerShell

Program PowerShell nie obsługuje obecnie niestandardowych procedur obsługi ponawiania prób. Nadal jednak istnieje możliwość zaimplementowania logiki ponawiania prób bezpośrednio w funkcji orkiestratora przy użyciu pętli, obsługi wyjątków i czasomierzy w celu wstrzykiwania opóźnień między ponownymi próbami.

Java

RetryHandler retryHandler = retryCtx -> {
    // Don't retry anything that derives from RuntimeException
    if (retryCtx.getLastFailure().isCausedBy(RuntimeException.class)) {
        return false;
    }

    // Quit after N attempts
    return retryCtx.getLastAttemptNumber() < 3;
};

TaskOptions options = new TaskOptions(retryHandler);
try {
    ctx.callActivity("FlakeyActivity", options).await();
} catch (TaskFailedException ex) {
    // Case when the retry handler returns false...
}

Limity czasu funkcji

Jeśli ukończenie działania funkcji trwa zbyt długo, możesz porzucić wywołanie funkcji w funkcji orkiestratora. Właściwym sposobem, aby to zrobić dzisiaj, jest utworzenie trwałego czasomierza z selektorem zadań "any", jak w poniższym przykładzie:

C# (InProc)

[FunctionName("TimerOrchestrator")]
public static async Task<bool> Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    TimeSpan timeout = TimeSpan.FromSeconds(30);
    DateTime deadline = context.CurrentUtcDateTime.Add(timeout);

    using (var cts = new CancellationTokenSource())
    {
        Task activityTask = context.CallActivityAsync("FlakyFunction");
        Task timeoutTask = context.CreateTimer(deadline, cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // success case
            cts.Cancel();
            return true;
        }
        else
        {
            // timeout case
            return false;
        }
    }
}

Uwaga

Poprzednie przykłady języka C# dotyczą rozszerzenia Durable Functions 2.x. W przypadku rozszerzenia Durable Functions 1.x należy użyć funkcji DurableOrchestrationContextIDurableOrchestrationContextzamiast . Aby uzyskać więcej informacji na temat różnic między wersjami, zobacz artykuł Wersje rozszerzenia Durable Functions.

C# (izolowane)

[Function("TimerOrchestrator")]
public static async Task<bool> Run([OrchestrationTrigger] TaskOrchestrationContext context)
{
    TimeSpan timeout = TimeSpan.FromSeconds(30);
    DateTime deadline = context.CurrentUtcDateTime.Add(timeout);

    using (var cts = new CancellationTokenSource())
    {
        Task activityTask = context.CallActivityAsync("FlakyFunction");
        Task timeoutTask = context.CreateTimer(deadline, cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // success case
            cts.Cancel();
            return true;
        }
        else
        {
            // timeout case
            return false;
        }
    }
}

JavaScript (PM3)

const df = require("durable-functions");
const moment = require("moment");

module.exports = df.orchestrator(function*(context) {
    const deadline = moment.utc(context.df.currentUtcDateTime).add(30, "s");

    const activityTask = context.df.callActivity("FlakyFunction");
    const timeoutTask = context.df.createTimer(deadline.toDate());

    const winner = yield context.df.Task.any([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        timeoutTask.cancel();
        return true;
    } else {
        // timeout case
        return false;
    }
});

JavaScript (PM4)

const df = require("durable-functions");
const { DateTime } = require("luxon");

df.app.orchestration("timerOrchestrator", function* (context) {
    const deadline = DateTime.fromJSDate(context.df.currentUtcDateTime).plus({ seconds: 30 });

    const activityTask = context.df.callActivity("flakyFunction");
    const timeoutTask = context.df.createTimer(deadline.toJSDate());

    const winner = yield context.df.Task.any([activityTask, timeoutTask]);
    if (winner === activityTask) {
        // success case
        timeoutTask.cancel();
        return true;
    } else {
        // timeout case
        return false;
    }
});

Python

import azure.functions as func
import azure.durable_functions as df
from datetime import datetime, timedelta

def orchestrator_function(context: df.DurableOrchestrationContext):
    deadline = context.current_utc_datetime + timedelta(seconds = 30)
    
    activity_task = context.call_activity('FlakyFunction')
    timeout_task = context.create_timer(deadline)

    winner = yield context.task_any(activity_task, timeout_task)
    if winner == activity_task:
        timeout_task.cancel()
        return True
    else:
        return False

main = df.Orchestrator.create(orchestrator_function)

Program PowerShell

param($Context)

$expiryTime = New-TimeSpan -Seconds 30

$activityTask = Invoke-DurableActivity -FunctionName 'FlakyFunction'-NoWait
$timerTask = Start-DurableTimer -Duration $expiryTime -NoWait

$winner = Wait-DurableTask -Task @($activityTask, $timerTask) -NoWait

if ($winner -eq $activityTask) {
    Stop-DurableTimerTask -Task $timerTask
    return $True
}
else {
    return $False
}

Java

@FunctionName("TimerOrchestrator")
public boolean timerOrchestrator(
        @DurableOrchestrationTrigger(name = "ctx") TaskOrchestrationContext ctx) {
    Task<Void> activityTask = ctx.callActivity("SlowFunction");
    Task<Void> timeoutTask = ctx.createTimer(Duration.ofMinutes(30));

    Task<?> winner = ctx.anyOf(activityTask, timeoutTask).await();
    if (winner == activityTask) {
        // success case
        return true;
    } else {
        // timeout case
        return false;
    }
}

Uwaga

Ten mechanizm w rzeczywistości nie zatrzymuje wykonywania funkcji aktywności będącej w toku. Zamiast tego po prostu umożliwia funkcji orkiestrator ignorowanie wyniku i przechodzenie dalej. Aby uzyskać więcej informacji, zobacz dokumentację czasomierzy .

Nieobsługiwane wyjątki

Jeśli funkcja orkiestratora zakończy się niepowodzeniem z nieobsługiwanym wyjątkiem, szczegóły wyjątku są rejestrowane, a wystąpienie kończy się stanem Failed .

Uwzględnij niestandardowe właściwości wyjątków dla szczegółów błędów (.NET w trybie izolowanym)

W przypadku wykonywania przepływów pracy Durable Task w modelu izolowanym .NET błędy zadań są automatycznie serializowane w obiekcie FailureDetails. Domyślnie ten obiekt zawiera standardowe pola, takie jak:

• ErrorType — nazwa typu wyjątku
• Komunikat — komunikat o wyjątku
• StackTrace — serializowany ślad stosu
• InnerFailure — zagnieżdżony obiekt FailureDetails dla wyjątków cyklicznych wewnętrznych

Począwszy od microsoft.Azure.Functions.Worker.Extensions.DurableTask v1.9.0, możesz rozszerzyć to zachowanie, implementując element IExceptionPropertiesProvider (zdefiniowany w pakiecie Microsoft.DurableTask.Worker, począwszy od pakietu w wersji 1.16.1). Ten dostawca definiuje, które typy wyjątków i które z ich właściwości powinny być uwzględnione w słowniku FailureDetails.Properties.

Uwaga

• Ta funkcja jest dostępna tylko w programie .NET Isolated . Obsługa języka Java zostanie dodana w przyszłej wersji.
• Upewnij się, że używasz biblioteki Microsoft.Azure.Functions.Worker.Extensions.DurableTask w wersji 1.9.0 lub nowszej.
• Upewnij się, że używasz narzędzia Microsoft.DurableTask.Worker w wersji 1.16.1 lub nowszej .

Implementowanie dostawcy właściwości wyjątku

Zaimplementuj niestandardowy element IExceptionPropertiesProvider, aby wyodrębnić i zwrócić wybrane właściwości dla określonych wyjątków. Zwrócony słownik zostanie zserializowany w polu Właściwości elementu FailureDetails, gdy zostanie zgłoszony pasujący typ wyjątku.

using Microsoft.DurableTask.Worker;

public class CustomExceptionPropertiesProvider : IExceptionPropertiesProvider
{
    public IDictionary<string, object?>? GetExceptionProperties(Exception exception)
    {
        return exception switch
        {
            ArgumentOutOfRangeException e => new Dictionary<string, object?>
            {
                ["ParamName"] = e.ParamName,
                ["ActualValue"] = e.ActualValue
            },
            InvalidOperationException e => new Dictionary<string, object?>
            {
                ["CustomHint"] = "Invalid operation occurred",
                ["TimestampUtc"] = DateTime.UtcNow
            },
            _ => null // Other exception types not handled
        };
    }
}

Rejestrowanie dostawcy

Zarejestruj niestandardowy element IExceptionPropertiesProvider na hoście procesu roboczego izolowanego platformy .NET, zazwyczaj w Program.cs:

using Microsoft.DurableTask.Worker;
using Microsoft.Extensions.DependencyInjection;

var host = new HostBuilder()
    .ConfigureFunctionsWorkerDefaults(builder =>
    {
        // Register custom exception properties provider
        builder.Services.AddSingleton<IExceptionPropertiesProvider, CustomExceptionPropertiesProvider>();
    })
    .Build();

host.Run();

Po zarejestrowaniu każdy wyjątek zgodny z jednym z obsługiwanych typów automatycznie uwzględni skonfigurowane właściwości w parametrze FailureDetails.

Przykładowe dane wyjściowe SzczegółyBłędu

Gdy wystąpi wyjątek zgodny z konfiguracją dostawcy, orkiestracja otrzymuje serializowaną strukturę FailureDetails w następujący sposób:

{
  "errorType": "TaskFailedException",
  "message": "Activity failed with an exception.",
  "stackTrace": "...",
  "innerFailure": {
    "errorType": "ArgumentOutOfRangeException",
    "message": "Specified argument was out of range.",
    "properties": {
      "ParamName": "count",
      "ActualValue": 42
    }
  }
}

Następne kroki

Dowiedz się więcej o wiecznych aranżacjach

Dowiedz się, jak diagnozować problemy