@gitkraken/core-gitlens 0.23.0 → 0.25.0

package/dist/plus/integrations/models/integration.d.ts

@@ -307,11 +307,24 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
   onSessionPublishing(publication: SessionPublication): void;
   protected invalidatePublishedSession(_publication: SessionPublication, _affectsPrimary: boolean): void;
   private static readonly requestExceptionLimit;
+  /** The primary connection's strikes (see {@link trackRequestException}). */
   private requestExceptionCount;
+  /** The strikes of every other connection, by connection id. */
+  private readonly connectionRequestExceptionCounts;
+  /**
+   * The connection a read's strikes and successes count against: `undefined` for the primary, which a read reaches
+   * by omitting `connectionId` or by naming it, else the connection named. The primary is named by its session's id,
+   * which is its connection's id, or, before that session is resolved, by the connection configured as primary.
+   */
+  private getSecondaryConnectionId;
   private resetRecoveryAccounting;
-  resetRequestExceptionCount(syncReqUsecase: SyncReqUsecase | 'all'): void;
   /**
-   * Resets request exceptions without resetting the amount of syncs
+   * Clears the strikes of the connection `connectionId` names (the primary when omitted) after a read of it
+   * succeeded, or of every connection for `'all'`.
+   */
+  resetRequestExceptionCount(syncReqUsecase: SyncReqUsecase | 'all', connectionId?: string): void;
+  /**
+   * Resets the primary connection's request exceptions without resetting the amount of syncs
    */
   smoothifyRequestExceptionCount(): void;
   reset(): Promise<void>;
@@ -408,9 +421,10 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
    * Shows one notice, and spends at most one strike, for a batch read whose targets failed with a server error or a
    * timeout. Our own clients leave both to the batch (see `reportRequestFailure`) instead of spending them per
    * target. `strike` is true only when every target failed and the call's own failure spent none: a call that
-   * answered some targets showed the host is up, and budgets strikes the same way as the rest of its failures.
+   * answered some targets showed the host is up, and budgets strikes the same way as the rest of its failures. The
+   * strike is `connectionId`'s, the connection the call read.
    */
-  protected reportDeferredRequestFailures(slots: readonly PromiseSettledResult<unknown>[] | undefined, strike: boolean): void;
+  protected reportDeferredRequestFailures(slots: readonly PromiseSettledResult<unknown>[] | undefined, strike: boolean, connectionId: string | undefined): void;
   /**
    * The failure handling of an etag cheap check that failed as a whole. Only a refused credential runs
    * {@link handleProviderException}, for its session expiry, re-authentication and strike. Anything else is only
@@ -431,7 +445,7 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
   private confirmCredential;
   /** Names each scoped refusal's cause (see {@link describeRefusal}); only once the credential is proven. */
   private nameRefusalCauses;
-  /** Returns whether it spent a strike toward disconnecting (see {@link trackRequestException}). */
+  /** Returns whether it spent a strike (see {@link trackRequestException}). */
   protected handleProviderException(syncReqUsecase: SyncReqUsecase, ex: Error, options?: {
     scope?: ScopedLogger | undefined;
     silent?: boolean;
@@ -447,8 +461,16 @@ export declare abstract class IntegrationBase<ID extends IntegrationIds = Integr
    * that instead of reading with an expired token or as a missing connection.
    */
   protected refreshSessionIfExpired(): Promise<Error | undefined>;
+  /**
+   * Spends a strike against the connection `connectionId` names (the primary when omitted); a server error or timeout
+   * our API clients report names the connection whose token made the request (see `reportRequestFailure`). At
+   * `requestExceptionLimit` the primary session is dropped for this session of the host. Another connection has no
+   * cached session to drop, since each read resolves its own, so its failures go on surfacing on its reads, and
+   * reaching the limit leaves the primary and every other connection as they are.
+   */
   trackRequestException(options?: {
     silent?: boolean;
+    connectionId?: string;
   }): void;
   isConnected(): Promise<boolean>;
   private ensureSession;

package/dist/plus/integrations/models/integration.js

@@ -12,11 +12,11 @@ import { isProviderUnreachableError, toError } from "../errors.js";
 import "../constants.js";
 import { isAzureProviderId } from "../providers/providerErrors.js";
 import { attributeScopedAuthFailures, hasOnlyScopedAuthFailures, markCredentialRefusals, toCollectionScopeFailure } from "../collectionMetadata.js";
-import { getSessionIdentity } from "../authentication/models.js";
-import { areDomainsOnSameHost } from "../utils/domain.utils.js";
-import { isSelfManagedHostIntegrationId } from "../utils/integration.utils.js";
 import { throwIfAllSettledFailed } from "../providers/utils/providerPaging.js";
+import { areDomainsOnSameHost } from "../utils/domain.utils.js";
 import { providersMetadata } from "../providers/models.js";
+import { isSelfManagedHostIntegrationId } from "../utils/integration.utils.js";
+import { getSessionIdentity } from "../authentication/models.js";
 import { RejectedTokenTracker } from "../authentication/rejectedTokenTracker.js";
 import { getCachedIssue } from "./issueCache.js";
 //#region ../plus/integrations/src/models/integration.ts
@@ -391,21 +391,46 @@ var IntegrationBase = class IntegrationBase {
 		this.invalidateDiscoveryCaches();
 	}
 	static requestExceptionLimit = 5;
+	/** The primary connection's strikes (see {@link trackRequestException}). */
 	requestExceptionCount = 0;
+	/** The strikes of every other connection, by connection id. */
+	connectionRequestExceptionCounts = /* @__PURE__ */ new Map();
+	/**
+	* The connection a read's strikes and successes count against: `undefined` for the primary, which a read reaches
+	* by omitting `connectionId` or by naming it, else the connection named. The primary is named by its session's id,
+	* which is its connection's id, or, before that session is resolved, by the connection configured as primary.
+	*/
+	getSecondaryConnectionId(connectionId) {
+		if (!connectionId || connectionId === this._session?.id) return void 0;
+		if (connectionId === this.authenticationService.getPrimaryConnectionId(this.authProvider.id, this.authProviderDescriptor)) return;
+		return connectionId;
+	}
 	resetRecoveryAccounting() {
 		this.requestExceptionCount = 0;
+		this.connectionRequestExceptionCounts.clear();
 		this._syncRequestsPerFailedUsecase.clear();
 		this._rejectedTokens.clear();
 	}
-	resetRequestExceptionCount(syncReqUsecase) {
-		this.requestExceptionCount = 0;
+	/**
+	* Clears the strikes of the connection `connectionId` names (the primary when omitted) after a read of it
+	* succeeded, or of every connection for `'all'`.
+	*/
+	resetRequestExceptionCount(syncReqUsecase, connectionId) {
 		if (syncReqUsecase === "all") {
 			this.resetRecoveryAccounting();
 			this.invalidateDiscoveryCaches();
-		} else this._syncRequestsPerFailedUsecase.delete(syncReqUsecase);
+			return;
+		}
+		const secondary = this.getSecondaryConnectionId(connectionId);
+		if (secondary != null) {
+			this.connectionRequestExceptionCounts.delete(secondary);
+			return;
+		}
+		this.requestExceptionCount = 0;
+		this._syncRequestsPerFailedUsecase.delete(syncReqUsecase);
 	}
 	/**
-	* Resets request exceptions without resetting the amount of syncs
+	* Resets the primary connection's request exceptions without resetting the amount of syncs
 	*/
 	smoothifyRequestExceptionCount() {
 		this.requestExceptionCount = 0;
@@ -423,6 +448,8 @@ var IntegrationBase = class IntegrationBase {
 	*/
 	switchConnection() {
 		this.onStoredTokensReplaced();
+		this.requestExceptionCount = 0;
+		this.connectionRequestExceptionCounts.clear();
 		return this.runSessionTransition(async () => {
 			if (this._session === void 0) return;
 			const wasConnected = this._session != null;
@@ -586,9 +613,10 @@ var IntegrationBase = class IntegrationBase {
 	* Shows one notice, and spends at most one strike, for a batch read whose targets failed with a server error or a
 	* timeout. Our own clients leave both to the batch (see `reportRequestFailure`) instead of spending them per
 	* target. `strike` is true only when every target failed and the call's own failure spent none: a call that
-	* answered some targets showed the host is up, and budgets strikes the same way as the rest of its failures.
+	* answered some targets showed the host is up, and budgets strikes the same way as the rest of its failures. The
+	* strike is `connectionId`'s, the connection the call read.
 	*/
-	reportDeferredRequestFailures(slots, strike) {
+	reportDeferredRequestFailures(slots, strike, connectionId) {
 		let notify;
 		for (const slot of slots ?? []) {
 			if (slot.status !== "rejected") continue;
@@ -596,7 +624,7 @@ var IntegrationBase = class IntegrationBase {
 			if (notify != null) break;
 		}
 		if (notify == null) return;
-		if (strike) this.trackRequestException();
+		if (strike) this.trackRequestException({ connectionId });
 		notify();
 	}
 	/**
@@ -646,7 +674,7 @@ var IntegrationBase = class IntegrationBase {
 		if (describeRefusal == null) return;
 		attributeScopedAuthFailures(metadata, (refusal, scope) => describeRefusal(session, refusal, scope));
 	}
-	/** Returns whether it spent a strike toward disconnecting (see {@link trackRequestException}). */
+	/** Returns whether it spent a strike (see {@link trackRequestException}). */
 	handleProviderException(syncReqUsecase, ex, options) {
 		if (isCancellationError(ex)) return false;
 		if (ex instanceof AuthenticationError) this._validatedCredentials.clear();
@@ -709,7 +737,21 @@ var IntegrationBase = class IntegrationBase {
 			this.missingExpirityReported = true;
 		}
 	}
+	/**
+	* Spends a strike against the connection `connectionId` names (the primary when omitted); a server error or timeout
+	* our API clients report names the connection whose token made the request (see `reportRequestFailure`). At
+	* `requestExceptionLimit` the primary session is dropped for this session of the host. Another connection has no
+	* cached session to drop, since each read resolves its own, so its failures go on surfacing on its reads, and
+	* reaching the limit leaves the primary and every other connection as they are.
+	*/
 	trackRequestException(options) {
+		const secondary = this.getSecondaryConnectionId(options?.connectionId);
+		if (secondary != null) {
+			const count = (this.connectionRequestExceptionCounts.get(secondary) ?? 0) + 1;
+			this.connectionRequestExceptionCounts.set(secondary, count);
+			if (count === IntegrationBase.requestExceptionLimit) _logger.warn(`${this.name} connection '${secondary}' has failed ${count} requests since its last success; it is not the primary, so nothing is disconnected`);
+			return;
+		}
 		this.requestExceptionCount++;
 		if (this.requestExceptionCount >= IntegrationBase.requestExceptionLimit && this._session !== null) {
 			if (!options?.silent) this.ctx.hooks?.ui?.onDisconnectedAfterTooManyFailures?.(this.name);
@@ -852,7 +894,7 @@ var IntegrationBase = class IntegrationBase {
 		const start = performance.now();
 		try {
 			const issues = await this.searchProviderMyIssues(session, resources != null ? Array.isArray(resources) ? resources : [resources] : void 0, cancellation);
-			this.resetRequestExceptionCount("searchMyIssues");
+			this.resetRequestExceptionCount("searchMyIssues", connectionId);
 			return {
 				value: issues,
 				duration: performance.now() - start
@@ -891,7 +933,7 @@ var IntegrationBase = class IntegrationBase {
 		try {
 			const result = await this.searchProviderMyIssuesWithTruncation(session, resources != null ? Array.isArray(resources) ? resources : [resources] : void 0, cancellation, options);
 			await this.confirmScopedAuthFailures(session, result?.metadata);
-			this.resetRequestExceptionCount("searchMyIssues");
+			this.resetRequestExceptionCount("searchMyIssues", connectionId);
 			return { value: result };
 		} catch (ex) {
 			this.handleProviderException("searchMyIssues", ex, {
@@ -939,7 +981,7 @@ var IntegrationBase = class IntegrationBase {
 				load: async () => {
 					try {
 						const issue = await getProviderIssue(session);
-						this.resetRequestExceptionCount("getIssue");
+						this.resetRequestExceptionCount("getIssue", connectionId);
 						return issue;
 					} catch (ex) {
 						if (!isCancellationError(ex)) this.handleProviderException("getIssue", toError(ex), {
@@ -969,7 +1011,7 @@ var IntegrationBase = class IntegrationBase {
 		return await this.ctx.cache.getCurrentAccount(this, (cacheable) => ({ value: (async () => {
 			try {
 				const account = await this.getProviderCurrentAccount?.(session, opts);
-				this.resetRequestExceptionCount("getCurrentAccount");
+				this.resetRequestExceptionCount("getCurrentAccount", connectionId);
 				return account;
 			} catch (ex) {
 				if (isCancellationError(ex) && !isProviderUnreachableError(ex)) {