SignalR current connections seem to always increase

[sommmen]

Hiya,

I'm using signalR in an asp net core / angular 17 project and looking at the performance counters i noticed:

Average Connection Duration (ms)	0
Current Connections	218
Total Connections Started	303
Total Connections Stopped	85
Total Connections Timed Out	1

I restarted the server yesterday which means overnight i somehow ended up with 200+ connections which seems way too much:

We have about 10 employees using the webapp which uses signalR. Lets say each employee has on average 5 tabs open, coming to 50 connections.
We then have a dashboard web app which comes to another 1 connection, and the background processor which also has 1 connection. I can see the current connection counter go up and down when open or close a tab in the webapp.

200+ active connections seem too much - Am i forgetting some client-side cleanups somewhere or what would cause such a high connection count?

Some reference code

Webapp:

fnRetry = () => Math.random() * (1000 - 350) + 350;

this.connection = new signalR.HubConnectionBuilder()
    .configureLogging(signalR.LogLevel.Warning)
    .withUrl(environment.api.baseUrl.replace(/\/api$/, endpoint), {
        accessTokenFactory: () => authService.getAuthorization().token,
        skipNegotiation: true,
        transport: signalR.HttpTransportType.WebSockets
        })
    .withAutomaticReconnect({
        nextRetryDelayInMilliseconds: this.fnRetry // indefinite retry ever N ms
    })
    .build();

this.connection.onclose((err) => {

    if (err === undefined) {
        return; // under normal operation.
    }

    console.error('Hub connection was closed', err);
    this.onConnectionChanged(false);

    // Restart when the server closes the request
    this.startConnectionSubscription = this.startHubconnection(this.connection, this.fnRetry)
        .subscribe({
            complete: this.startConnectionSubscription = null
        });
});

this.connection.onreconnecting(() => {
    this.onConnectionChanged(false);
});

this.connection.onreconnected(() => {
    this.onConnectionChanged(true);
});

startHubconnection(connection: signalR.HubConnection, fnRetry: () => number) {
    return defer(() => from(connection.start()))
        .pipe(
            catchError((err) => {
                this.onConnectionChanged(false);
                return throwError(() => err);
            }),
            retry({
                delay() {
                    return timer(fnRetry());
                },
            }), // indefinite retry ever N ms
            tap(() => this.onConnectionChanged(true))
        );
}

The c# client apps pretty much have the same setup:

services.AddTransient<IOrderHubClient, OrderHubClient>(c =>
{
    var tokenManager = c.GetRequiredService<IOPGWebApiTokenManager>();
    return ActivatorUtilities.CreateInstance<OrderHubClient>(c,
        new HubConnectionBuilder()
            .WithUrl(new Uri(baseWebUrl + "/orderHub"), opt =>
            {
                opt.SkipNegotiation = true;
                opt.Transports = HttpTransportType.WebSockets;
                opt.AccessTokenProvider = () => tokenManager.GetToken(CancellationToken.None)!;
            })
            .WithAutomaticReconnect()
            .Build());
});

// Should be properly disposed (clients get created ad-hoc):
// OrderHubClient
#region IDisposable

protected virtual void Dispose(bool disposing)
{
    if (disposing)
    {
        _subscription.Dispose();
        _cancellationTokenSource.Dispose();
        _ = _connection.DisposeAsync().AsTask();
    }
}

/// <inheritdoc />
public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);
}

protected virtual async ValueTask DisposeAsyncCore()
{
    await CastAndDispose(_subscription);
    await CastAndDispose(_cancellationTokenSource);
    await _connection.DisposeAsync();

    return;

    static async ValueTask CastAndDispose(IDisposable resource)
    {
        if (resource is IAsyncDisposable resourceAsyncDisposable)
            await resourceAsyncDisposable.DisposeAsync();
        else
            resource.Dispose();
    }
}

/// <inheritdoc />
public async ValueTask DisposeAsync()
{
    await DisposeAsyncCore();
    GC.SuppressFinalize(this);
}

#endregion