Orkestrasyonlardaki hataları ve yeniden denemeleri yönetme

Kodda Durable Functions düzenlemelerini uyguladığınızdan, dilinizin yerleşik hata işleme özelliklerini kullanırsınız. Hata işleme ve telafi için yeni kavramlar gerekmez, ancak birkaç düzenleme davranışı bilinmeye değer.

Uyarı

Azure İşlevleri için Node.js programlama modelinin 4. sürümü genel olarak kullanılabilir. v4 modeli, JavaScript ve TypeScript geliştiricileri için daha esnek ve sezgisel bir deneyim sağlamak üzere tasarlanmıştır. v3 ile v4 arasındaki farklar hakkında daha fazla bilgi için geçiş kılavuzuna bakın.

Aşağıdaki kod parçacıklarında JavaScript (PM4), yeni deneyim olan v4 programlama modelini belirtir.

Bulut hizmetlerini kullanan uygulamaların hataları işlemesi gerekir ve istemci tarafı yeniden denemeleri tasarımın önemli bir parçasıdır. Dayanıklı Görev SDK'ları, güçlü iş akışları oluşturmanıza yardımcı olmak için hata işleme, yeniden denemeler ve zaman aşımları desteği içerir.

Etkinlik işlevlerindeki ve alt düzenlemelerdeki hataları işleme

Durable Functions'da, etkinlik işlevleri veya alt düzenlemelerde oluşan işlenmeyen özel durumlar standartlaştırılmış özel durum türleri kullanılarak orchestrator işlevine geri gönderilir.

Aşağıdaki düzenleyici işlevi iki hesap arasında fon aktarır:

Yalıtılmış çalışan modeli

Durable Functions C# Yalıtılmış'ta ele alınmamış istisnalar TaskFailedException olarak gösterilir.

Özel durum iletisi genellikle hataya hangi etkinlik işlevlerinin veya alt düzenlemelerin neden olduğunu tanımlar. Daha ayrıntılı hata bilgilerine erişmek için FailureDetails özelliğini inceleyin.

[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
            });
    }
}

Uyarı

  • Özel durum iletisi genellikle hataya hangi etkinlik işlevlerinin veya alt düzenlemelerin neden olduğunu tanımlar. Daha ayrıntılı hata bilgilerine erişmek için özelliğini inceleyin FailureDetails .
  • Varsayılan olarak, FailureDetailshata türünü, hata iletisini, yığın izlemesini ve iç içe geçmiş iç özel durumları (her biri özyinelemeli FailureDetails nesne olarak temsil edilir) içerir. Ek ek özel durum özelliklerini hata çıktısına dahil etmek için bakınız Hata Ayrıntıları için Özel Durum Özelliklerini Dahil Etmek (.NET Yalıtılmış).

Önemli

Geçiş notu (işlem içiden yalıtılmışa): İşlem içi modelde, FunctionFailedException.InnerException doğrudan dönüştürüp inceleyebileceğiniz etkinlik tarafından atılan orijinal istisna nesnesini içerir. Yalıtılmış çalışan modelinde, özgün istisnayı bir olarak içermez. Bunun yerine, hata ayrıntıları yalnızca FailureDetails özelliği aracılığıyla, dize tabanlı özellikler (ErrorType, ErrorMessage, StackTrace) sağlayarak kullanılabilir. Özgün özel durum nesnesini doğrudan oluşturamaz veya bu nesneye erişemezsiniz. Özgün özel durum türünü denetlemek için kullanın FailureDetails.IsCausedBy<T>() .


İşlem içi model

Dayanıklı İşlevler C# süreç içi, işlenmeyen özel durumlar FunctionFailedException olarak fırlatılır.

Özel durum iletisi genellikle başarısız olan etkinlik işlevini veya alt düzenlemeyi içerir. Ayrıntılar için InnerException'yi inceleyin.

[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
            });
    }
}

Uyarı

Önceki C# örnekleri 2.x Durable Functions kullanır. Durable Functions 1.x için DurableOrchestrationContext yerine IDurableOrchestrationContext kullanın. Sürüm farklılıkları için Durable Functions sürümleri makalesine bakın.

İlk CreditAccount işlev çağrısı başarısız olursa orchestrator işlevi, fonları kaynak hesaba geri yatırarak telafi eder.

Dayanıklı Görev SDK'larında, etkinlikler veya alt düzenlemelerde oluşan işlenmeyen özel durumlar, TaskFailedException türü kullanılarak düzenleyiciye geri iletilir. Özel durumun FailureDetails özelliği hata hakkında ayrıntılı bilgi sağlar.

using Microsoft.DurableTask;

[DurableTask(nameof(TransferFundsOrchestration))]
public class TransferFundsOrchestration : TaskOrchestrator<TransferOperation, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, TransferOperation transfer)
    {
        await context.CallActivityAsync(
            nameof(DebitAccountActivity),
            new AccountOperation { Account = transfer.SourceAccount, Amount = transfer.Amount });

        try
        {
            await context.CallActivityAsync(
                nameof(CreditAccountActivity),
                new AccountOperation { Account = transfer.DestinationAccount, Amount = transfer.Amount });
        }
        catch (TaskFailedException ex)
        {
            // Log the failure details
            var details = ex.FailureDetails;

            // Compensate by refunding the source account
            await context.CallActivityAsync(
                nameof(CreditAccountActivity),
                new AccountOperation { Account = transfer.SourceAccount, Amount = transfer.Amount });

            return $"Transfer failed: {details.ErrorMessage}. Compensation completed.";
        }

        return "Transfer completed successfully";
    }
}

CreditAccount etkinliği başarısız olursa düzenleyici özel durumu yakalar ve fonları kaynak hesaba geri yatırarak telafi eder.

Çoklu etkinlik çağrılarıyla ilgili hataları işleme (fan-out/fan-in)

Birden çok etkinlik çağrısını paralel (fan-out/fan-in deseni) çalıştırmak için Task.WhenAll kullandığınızda ve bir veya daha fazla etkinlik başarısız olduğunda, await yalnızca ilk özel durumu atar. Tüm hatalara erişmek için Exception tarafından döndürülen Task üzerindeki Task.WhenAll özelliğini inceleyin.

Yalıtılmış çalışan modeli 
var tasks = new[]
{
    context.CallActivityAsync("Activity1", input1),
    context.CallActivityAsync("Activity2", input2),
    context.CallActivityAsync("Activity3", input3),
};

var allTask = Task.WhenAll(tasks);
try
{
    await allTask;
}
catch (TaskFailedException)
{
    // 'await' rethrows only the first exception. To inspect all failures,
    // check allTask.Exception, which is an AggregateException.
    if (allTask.Exception != null)
    {
        foreach (var inner in allTask.Exception.InnerExceptions)
        {
            if (inner is TaskFailedException taskFailed)
            {
                // Use taskFailed.FailureDetails to inspect error details
                var errorType = taskFailed.FailureDetails.ErrorType;
                var errorMessage = taskFailed.FailureDetails.ErrorMessage;
            }
        }
    }
}

İşlem içi model 
var tasks = new[]
{
    context.CallActivityAsync("Activity1", input1),
    context.CallActivityAsync("Activity2", input2),
    context.CallActivityAsync("Activity3", input3),
};

var allTask = Task.WhenAll(tasks);
try
{
    await allTask;
}
catch (FunctionFailedException)
{
    // 'await' rethrows only the first exception. To inspect all failures,
    // check allTask.Exception, which is an AggregateException.
    if (allTask.Exception != null)
    {
        foreach (var inner in allTask.Exception.InnerExceptions)
        {
            if (inner is FunctionFailedException funcFailed)
            {
                // Use funcFailed.InnerException to access the original exception
            }
        }
    }
}

Varlık işlevlerindeki hataları işleme

Varlık işlevlerinde özel durum işleme, Durable Functions barındırma modeline bağlıdır:

Yalıtılmış çalışan modeli

C# yalıtılmış Durable Functions çalışma zamanı, varlık işlevi özel durumlarını EntityOperationFailedException içinde sarar. Özgün özel durum ayrıntılarını almak için, FailureDetails özelliğini inceleyin.

[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>();
}

İşlem içi model

C# ile süreç içi Durable Functions'da, varlık işlevleri özgün özel durum türlerini orkestratöre döndürür.

[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 is 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;
    }
}

Hatada otomatik yeniden deneme

Etkinlik işlevlerini veya alt düzenleme işlevlerini çağırdığınızda, otomatik bir yeniden deneme ilkesi belirtin. Aşağıdaki örnek bir işlevi en fazla üç kez çağırır ve yeniden denemeler arasında beş saniye bekler:

Yalıtılmış çalışan modeli 
[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);

    // ...
}

İşlem içi model 
[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);

    // ...
}

Uyarı

Önceki C# örnekleri Durable Functions 2.x içindir. Durable Functions 1.x için DurableOrchestrationContext yerine IDurableOrchestrationContext kullanmanız gerekir. Sürümler arasındaki farklar hakkında daha fazla bilgi için Dayanıklı İşlevler sürümleri makalesine bakın.

Önceki örnekteki etkinlik işlevi çağrısı, otomatik yeniden deneme ilkesi yapılandırmak için bir parametre kullanır. İlkeyi şu seçeneklerle özelleştirin:

  • En fazla deneme sayısı: En fazla deneme sayısı. 1 olarak ayarlanırsa yeniden deneme gerçekleşmez.
  • İlk yeniden deneme aralığı: İlk yeniden deneme denemesi öncesinde bek süre.
  • Geri alma katsayısı: Geri alma artış oranını belirlemek için kullanılan katsayı. Varsayılan değer 1'tir.
  • En fazla yeniden deneme aralığı: Yeniden deneme girişimleri arasında bek süre üst sınırı.
  • Yeniden deneme zaman aşımı: Yeniden deneme için harcayacak maksimum süre. Varsayılan olarak, yeniden denemeler süresiz olarak devam eder.

Dayanıklı Görev SDK'ları, sağlanan ilkeye göre başarısız etkinlikleri yeniden deneyen alternatif zamanlama yöntemlerini içerir. Bu yöntemler, web hizmetlerinden veri okuyan veya bir veritabanına etkili yazma işlemleri gerçekleştiren etkinlikler için kullanışlıdır.

using Microsoft.DurableTask;

[DurableTask(nameof(OrchestratorWithRetry))]
public class OrchestratorWithRetry : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, string input)
    {
        // Configure retry policy
        var retryPolicy = new RetryPolicy(
            maxNumberOfAttempts: 3,
            firstRetryInterval: TimeSpan.FromSeconds(5),
            backoffCoefficient: 2.0,
            maxRetryInterval: TimeSpan.FromMinutes(1),
            retryTimeout: TimeSpan.FromMinutes(5));

        var options = TaskOptions.FromRetryPolicy(retryPolicy);

        // Call activity with automatic retry
        string result = await context.CallActivityAsync<string>(
            nameof(UnreliableActivity), input, options);

        return result;
    }
}

Yeniden deneme ilkesi seçenekleri şunlardır:

  • En fazla deneme sayısı: En fazla yeniden deneme denemesi sayısı. 1 olarak ayarlanırsa yeniden deneme gerçekleşmez.
  • İlk yeniden deneme aralığı: İlk yeniden deneme denemesi öncesinde bek süre.
  • Geri alma katsayısı: Geri alma artış oranını belirlemek için kullanılan katsayı. Varsayılan değer 1'tir.
  • En fazla yeniden deneme aralığı: Yeniden deneme girişimleri arasında bek süre üst sınırı.
  • Yeniden deneme zaman aşımı: Yeniden denemeler yapmak için harcayacak maksimum süre.

Özel tekrar deneme işleyicileri

.NET ve Java'da, bildirime dayalı yeniden deneme ilkeleri yeterince etkili olmadığında, kodda yeniden deneme yöneticileri uygulayın. Diğer dillerde, yeniden denemeler arasında gecikmeye neden olan döngüleri, özel durum işlemeyi ve zamanlayıcıları kullanarak yeniden deneme mantığını uygulayın.

Yalıtılmış çalışan modeli 
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...
}

İşlem içi model 
RetryOptions retryOptions = new RetryOptions(
    firstRetryInterval: TimeSpan.FromSeconds(5),
    maxNumberOfAttempts: int.MaxValue)
{
    Handle = exception =>
    {
        // Return true to handle and retry, or false to throw.
        if (exception is TaskFailedException failure)
        {
            // Exceptions from task activities are always this type. Inspect the
            // inner exception for more details.
        }

        return false;
    }
};

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

Özel tekrar deneme işleyicileri

.NET ve Java yeniden deneme mantığını denetlemek için kodda yeniden deneme işleyicileri uygulayın. Bildirim temelli yeniden deneme ilkeleri yeterince açıklayıcı olmadığında bu yaklaşım yararlıdır.

using Microsoft.DurableTask;

[DurableTask(nameof(OrchestratorWithCustomRetry))]
public class OrchestratorWithCustomRetry : TaskOrchestrator<string, string>
{
    public override async Task<string> RunAsync(
        TaskOrchestrationContext context, string input)
    {
        // Custom retry handler with conditional logic
        TaskOptions retryOptions = TaskOptions.FromRetryHandler(retryContext =>
        {
            // Don't retry if it's a validation error
            if (retryContext.LastFailure.IsCausedBy<ArgumentException>())
            {
                return false;
            }

            // Retry up to 5 times for transient errors
            return retryContext.LastAttemptNumber < 5;
        });

        try
        {
            return await context.CallActivityAsync<string>(
                nameof(UnreliableActivity), input, retryOptions);
        }
        catch (TaskFailedException)
        {
            // All retries exhausted
            return "Operation failed after all retries";
        }
    }
}

İşlev zaman aşımları

Bir işlev çağrısı çok uzun sürüyorsa, orchestrator işlevinde zaman aşımına uğratın. Aşağıdaki örnekte olduğu gibi bir görev seçici ile dayanıklı bir any zamanlayıcı oluşturun:

Yalıtılmış çalışan modeli 
[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;
        }
    }
}

İşlem içi model 
[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;
        }
    }
}

Uyarı

Önceki C# örnekleri Durable Functions 2.x içindir. Durable Functions 1.x için DurableOrchestrationContext yerine IDurableOrchestrationContext kullanmanız gerekir. Sürümler arasındaki farklar hakkında daha fazla bilgi için Dayanıklı İşlevler sürümleri makalesine bakın.

Uyarı

Bu mekanizma, devam etmekte olan etkinlik işlevi yürütmesini sonlandırmaz. Orchestrator işlevinin sonucu yoksayıp devam etmesini sağlar. Daha fazla bilgi için bkz . Zamanlayıcılar.

Etkinlik zaman aşımları

Bir etkinlik çağrısı çok uzun sürüyorsa, beklemeyi durdurabilirsiniz. Dayanıklı bir zamanlayıcı oluşturun ve etkinlik görevine karşı yarıştırın.

using Microsoft.DurableTask;
using System;
using System.Threading;
using System.Threading.Tasks;

[DurableTask(nameof(OrchestratorWithTimeout))]
public class OrchestratorWithTimeout : TaskOrchestrator<string, bool>
{
    public override async Task<bool> RunAsync(
        TaskOrchestrationContext context, string input)
    {
        TimeSpan timeout = TimeSpan.FromSeconds(30);
        DateTime deadline = context.CurrentUtcDateTime.Add(timeout);

        using var cts = new CancellationTokenSource();
        Task activityTask = context.CallActivityAsync(nameof(SlowActivity), input);
        Task timeoutTask = context.CreateTimer(deadline, cts.Token);

        Task winner = await Task.WhenAny(activityTask, timeoutTask);
        if (winner == activityTask)
        {
            // Activity completed in time - cancel the timer
            cts.Cancel();
            return true;
        }
        else
        {
            // Timeout occurred
            return false;
        }
    }
}

Uyarı

Bu mekanizma, devam etmekte olan etkinlik yürütmesini sonlandırmaz. Orkestratörün sonucu yoksayıp devam etmesini sağlar. Daha fazla bilgi için Zamanlayıcılar belgelerine bakın.

İşlenmeyen özel durumlar

Orchestrator işlevi işlenmeyen bir özel durumla başarısız olursa, çalışma zamanı özel durum ayrıntılarını günlüğe kaydeder ve örnek Failed durumu ile tamamlanır.

FailureDetails için özel durum özellikleri ekleyin (.NET Yalıtılmış)

.NET Yalıtılmış modelini kullanan Dayanıklı Görev iş akışlarında, görev hataları bir FailureDetails nesnesine serileştirilir. Varsayılan olarak, nesne şu alanları içerir:

  • ErrorType—Özel durum türü adı
  • Message—Özel durum mesajı
  • StackTrace—Seri hale getirilmiş yığın izlemesi
  • InnerFailure—İç özel durumlar için iç içe FailureDetails nesne

Microsoft.Azure.Functions.Worker.Extensions.DurableTask v1.9.0 itibarıyla, IExceptionPropertiesProvider uygulayarak bu davranışı genişletebilirsiniz (bu özellik Microsoft.DurableTask.Worker itibarıyla paketinde tanımlanmıştır). Bu sağlayıcı, sözlüğe eklenecek özel durum türlerini ve özelliklerini FailureDetails.Properties tanımlar.

Uyarı

  • Bu özellik yalnızca .NET Isolated içinde kullanılabilir. Java desteği henüz sağlanmamıştır.
  • Emin olun ki Microsoft.Azure.Functions.Worker.Extensions.DurableTask v1.9.0 veya daha üzeri bir sürümü kullanıyorsunuz.
  • Microsoft.DurableTask.Worker v1.16.1 veya üzerini kullandığınızdan emin olun.

Özel durum özellikleri sağlayıcısı uygulama

Seçili özellikleri ayıklayıp döndürmek için önem verdiğiniz özel durumlar için özel bir IExceptionPropertiesProvider uygulayın. Döndürülen sözlük, eşleşen bir özel durum türü atıldığında PropertiesFailureDetails alanına serileştirilir.

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
        };
    }
}

Sağlayıcıyı kaydetme

Program.cs'da özel IExceptionPropertiesProvider .NET Yalıtılmış çalışan konağına kaydedin:

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();

Sağlayıcıyı kaydettikten sonra, işlenen bir türle eşleşen tüm özel durumlar, FailureDetails içinde yapılandırılan özellikleri otomatik olarak içerir.

Örnek FailureDetails çıkışı

Sağlayıcınızın yapılandırmasıyla eşleşen bir özel durum oluştuğunda düzenleme aşağıdaki gibi serileştirilmiş FailureDetails bir nesne alır:

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

İşlenmeyen özel durumlar

İşlenmeyen bir özel durum nedeniyle bir orkestratör başarısız olursa, çalışma zamanı özel durum ayrıntılarını günlüğe kaydeder ve örnek Failed durumu ile tamamlanır. , TaskFailedException hata türünü, iletiyi ve yığın izlemesini içeren bir FailureDetails özelliğe sahiptir.

Sonraki Adımlar

Ebedi düzenleme

Sorunları tanılama

Dayanıklı Görev SDK'larını kullanmaya başlama

  • GitHubJavaScript SDK örnekleri>
  • Last updated on