< Summary - AsyncResponse (Release / net8.0+net10.0 / unit+integration)

Information
Class: AsyncResponse.Transports.SqlServer.SqlServerTransportRetry
Assembly: AsyncResponse.Transports.SqlServer
File(s): /_/src/Transports/AsyncResponse.Transports.SqlServer/SqlServerWorkerTransport.cs
Line coverage
100%
Covered lines: 2
Uncovered lines: 0
Coverable lines: 2
Total lines: 103
Line coverage: 100%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
ExecuteAsync(...)100%11100%
IsTransient(...)100%11100%

File(s)

/_/src/Transports/AsyncResponse.Transports.SqlServer/SqlServerWorkerTransport.cs

#LineLine coverage
 1using AsyncResponse.Internal;
 2using Microsoft.Extensions.Options;
 3using System.Diagnostics;
 4using System.Text.Json;
 5
 6namespace AsyncResponse.Transports.SqlServer;
 7
 8/// <summary>Publishes <see cref="WorkerJobEnvelope"/> messages to the SQL Server worker queue.</summary>
 9public sealed class SqlServerWorkerTransport : IWorkerTransport, IDelayedWorkerTransport
 10{
 11    private readonly SqlServerAsyncResponseTransportOptions _options;
 12    private readonly SqlServerTransportStore _store;
 13
 14    /// <summary>Creates a SQL Server worker transport over the configured connection string.</summary>
 15    public SqlServerWorkerTransport(IOptions<SqlServerAsyncResponseTransportOptions> options)
 16        : this(options, new SqlServerTransportStore(options))
 17    {
 18    }
 19
 20    internal SqlServerWorkerTransport(
 21        IOptions<SqlServerAsyncResponseTransportOptions> options,
 22        SqlServerTransportStore store)
 23    {
 24        _options = options.Value;
 25        SqlServerTransportOptionsValidator.ValidateCommon(_options);
 26        _store = store;
 27    }
 28
 29    /// <inheritdoc />
 30    public Task PublishAsync(WorkerJobEnvelope job, CancellationToken cancellationToken = default)
 31        => PublishCoreAsync(job, delay: null, cancellationToken);
 32
 33    /// <inheritdoc cref="IDelayedWorkerTransport.MaxPublishDelay"/>
 34    /// <remarks>The due time is a database timestamp; no per-hop cap applies.</remarks>
 35    public TimeSpan MaxPublishDelay => AsyncResponseChannelOptions.MaxPersistenceTtl;
 36
 37    /// <inheritdoc cref="IDelayedWorkerTransport.PublishAsync(WorkerJobEnvelope, TimeSpan, CancellationToken)"/>
 38    public Task PublishAsync(WorkerJobEnvelope job, TimeSpan delay, CancellationToken cancellationToken = default)
 39    {
 40        ArgumentOutOfRangeException.ThrowIfGreaterThan(delay, MaxPublishDelay);
 41        return PublishCoreAsync(job, delay > TimeSpan.Zero ? delay : null, cancellationToken);
 42    }
 43
 44    private async Task PublishCoreAsync(WorkerJobEnvelope job, TimeSpan? delay, CancellationToken cancellationToken)
 45    {
 46        ArgumentNullException.ThrowIfNull(job);
 47
 48        using var activity = AsyncResponseDiagnostics.StartActivity(
 49            "asyncresponse.worker.publish",
 50            ActivityKind.Producer,
 51            job.CorrelationId);
 52        activity?.SetTag("asyncresponse.transport", "sqlserver");
 53        activity?.SetTag("messaging.system", "sqlserver");
 54        activity?.SetTag("messaging.destination.name", _options.WorkerQueue);
 55        AsyncResponseDiagnostics.SetReplyTarget(activity, job.ReplyTarget);
 56        AsyncResponseDiagnostics.SetWorker(activity, job.Call);
 57
 58        try
 59        {
 60            var headers = string.IsNullOrWhiteSpace(job.CorrelationId)
 61                ? null
 62                : new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
 63                {
 64                    [_options.CorrelationIdHeader] = job.CorrelationId!
 65                };
 66
 67            var payload = AsyncResponseJson.Serialize(job);
 68            // Stable id outside the retry loop so a retried publish is idempotent rather than enqueuing
 69            // the same worker job twice.
 70            var messageId = Guid.NewGuid();
 71            if (delay is { } delayTag)
 72                activity?.SetTag("asyncresponse.worker.delay_seconds", delayTag.TotalSeconds);
 73            await SqlServerTransportRetry.ExecuteAsync(
 74                async token =>
 75                {
 76                    await _store.PublishAsync(messageId, _options.WorkerQueue, payload, headers, token, delay).Configure
 77                    return true;
 78                },
 79                _options.PublishMaxAttempts,
 80                _options.PublishRetryBaseDelay,
 81                _options.PublishRetryMaxDelay,
 82                cancellationToken).ConfigureAwait(false);
 83        }
 84        catch (Exception ex)
 85        {
 86            AsyncResponseDiagnostics.SetError(activity, ex);
 87            throw;
 88        }
 89    }
 90}
 91
 92internal static class SqlServerTransportRetry
 93{
 94    public static Task<T> ExecuteAsync<T>(
 95        Func<CancellationToken, Task<T>> action,
 96        int maxAttempts,
 97        TimeSpan baseDelay,
 98        TimeSpan maxDelay,
 99        CancellationToken cancellationToken)
 414100        => AsyncResponseRetry.ExecuteAsync(action, IsTransient, maxAttempts, baseDelay, maxDelay, cancellationToken);
 101
 84102    public static bool IsTransient(Exception exception) => SqlServerTransientFaults.IsTransient(exception);
 103}