persisted documents as well?

Author: n1ru4l

packages/libraries/apollo/src/index.ts

@@ -2,14 +2,14 @@ import { GraphQLError, type DocumentNode } from 'graphql';
 import type { ApolloServerPlugin, HTTPGraphQLRequest } from '@apollo/server';
 import {
   autoDisposeSymbol,
-  CDNArtifactFetcherCircuitBreakerConfiguration,
   createCDNArtifactFetcher,
   createHive as createHiveClient,
   HiveClient,
   HivePluginOptions,
   isHiveClient,
   joinUrl,
   Logger,
+  type CDNArtifactFetcherCircuitBreakerConfiguration,
 } from '@graphql-hive/core';
 import { version } from './version.js';
 

packages/libraries/core/src/client/agent.ts

@@ -1,35 +1,15 @@
 import CircuitBreaker from '../circuit-breaker/circuit.js';
 import { version } from '../version.js';
+import {
+  CircuitBreakerConfiguration,
+  defaultCircuitBreakerConfiguration,
+} from './circuit-breaker.js';
 import { http } from './http-client.js';
 import type { Logger } from './types.js';
 import { createHiveLogger } from './utils.js';
 
 type ReadOnlyResponse = Pick<Response, 'status' | 'text' | 'json' | 'statusText'>;
 
-export type AgentCircuitBreakerConfiguration = {
-  /**
-   * Percentage after what the circuit breaker should kick in.
-   * Default: 50
-   */
-  errorThresholdPercentage: number;
-  /**
-   * Count of requests before starting evaluating.
-   * Default: 5
-   */
-  volumeThreshold: number;
-  /**
-   * After what time the circuit breaker is attempting to retry sending requests in milliseconds
-   * Default: 30_000
-   */
-  resetTimeout: number;
-};
-
-const defaultCircuitBreakerConfiguration: AgentCircuitBreakerConfiguration = {
-  errorThresholdPercentage: 50,
-  volumeThreshold: 10,
-  resetTimeout: 30_000,
-};
-
 export interface AgentOptions {
   enabled?: boolean;
   name?: string;
@@ -76,7 +56,7 @@ export interface AgentOptions {
    * false -> Disable
    * object -> use custom configuration see {AgentCircuitBreakerConfiguration}
    */
-  circuitBreaker?: boolean | AgentCircuitBreakerConfiguration;
+  circuitBreaker?: boolean | CircuitBreakerConfiguration;
   /**
    * WHATWG Compatible fetch implementation
    * used by the agent to send reports
@@ -101,7 +81,7 @@ export function createAgent<TEvent>(
   },
 ) {
   const options: Required<Omit<AgentOptions, 'fetch' | 'debug' | 'logger' | 'circuitBreaker'>> & {
-    circuitBreaker: AgentCircuitBreakerConfiguration | null;
+    circuitBreaker: CircuitBreakerConfiguration | null;
   } = {
     timeout: 30_000,
     enabled: true,

packages/libraries/core/src/client/artifacts.ts

@@ -1,33 +1,13 @@
 import CircuitBreaker from '../circuit-breaker/circuit.js';
 import { version } from '../version.js';
+import {
+  CircuitBreakerConfiguration,
+  defaultCircuitBreakerConfiguration,
+} from './circuit-breaker.js';
 import { http } from './http-client.js';
 import type { Logger } from './types.js';
 import { createHash, createHiveLogger } from './utils.js';
 
-export type CDNArtifactFetcherCircuitBreakerConfiguration = {
-  /**
-   * Percentage after what the circuit breaker should kick in.
-   * Default: 50
-   */
-  errorThresholdPercentage: number;
-  /**
-   * Count of requests before starting evaluating.
-   * Default: 5
-   */
-  volumeThreshold: number;
-  /**
-   * After what time the circuit breaker is attempting to retry sending requests in milliseconds
-   * Default: 30_000
-   */
-  resetTimeout: number;
-};
-
-const defaultCircuitBreakerConfiguration: CDNArtifactFetcherCircuitBreakerConfiguration = {
-  errorThresholdPercentage: 50,
-  volumeThreshold: 10,
-  resetTimeout: 30_000,
-};
-
 type CreateCDNArtifactFetcherArgs = {
   endpoint: string;
   accessKey: string;
@@ -36,7 +16,7 @@ type CreateCDNArtifactFetcherArgs = {
     name: string;
     version: string;
   };
-  circuitBreaker?: CDNArtifactFetcherCircuitBreakerConfiguration;
+  circuitBreaker?: CircuitBreakerConfiguration;
   logger?: Logger;
   fetch?: typeof fetch;
 };

packages/libraries/core/src/client/persisted-documents.ts

@@ -1,5 +1,7 @@
 import type { PromiseOrValue } from 'graphql/jsutils/PromiseOrValue.js';
 import LRU from 'tiny-lru';
+import CircuitBreaker from '../circuit-breaker/circuit.js';
+import { defaultCircuitBreakerConfiguration } from './circuit-breaker.js';
 import { http } from './http-client.js';
 import type { PersistedDocumentsConfiguration } from './types';
 import type { HiveLogger } from './utils.js';
@@ -8,6 +10,10 @@ type HeadersObject = {
   get(name: string): string | null;
 };
 
+function isRequestOk(response: Response) {
+  return response.status === 200 || response.status === 404;
+}
+
 export function createPersistedDocuments(
   config: PersistedDocumentsConfiguration & {
     logger: HiveLogger;
@@ -33,44 +39,61 @@ export function createPersistedDocuments(
   /** if there is already a in-flight request for a document, we re-use it. */
   const fetchCache = new Map<string, Promise<string | null>>();
 
-  /** Batch load a persisted documents */
-  function loadPersistedDocument(documentId: string) {
-    const document = persistedDocumentsCache.get(documentId);
-    if (document) {
-      return document;
-    }
-
-    const cdnDocumentId = documentId.replaceAll('~', '/');
-
-    const url = config.cdn.endpoint + '/apps/' + cdnDocumentId;
-    let promise = fetchCache.get(url);
+  const circuitBreaker = new CircuitBreaker(
+    async function doFetch(args: { url: string; documentId: string }) {
+      const signal = circuitBreaker.getSignal();
 
-    if (!promise) {
-      promise = http
-        .get(url, {
+      const promise = http
+        .get(args.url, {
           headers: {
             'X-Hive-CDN-Key': config.cdn.accessToken,
           },
           logger: config.logger,
-          isRequestOk: response => response.status === 200 || response.status === 404,
+          isRequestOk,
           fetchImplementation: config.fetch,
+          signal,
         })
         .then(async response => {
           if (response.status !== 200) {
             return null;
           }
           const text = await response.text();
-          persistedDocumentsCache.set(documentId, text);
+          persistedDocumentsCache.set(args.documentId, text);
           return text;
         })
         .finally(() => {
-          fetchCache.delete(url);
+          fetchCache.delete(args.url);
         });
+      fetchCache.set(args.url, promise);
 
-      fetchCache.set(url, promise);
+      return await promise;
+    },
+    {
+      ...(config.circuitBreaker ?? defaultCircuitBreakerConfiguration),
+      timeout: false,
+      autoRenewAbortController: true,
+    },
+  );
+
+  /** Batch load a persisted documents */
+  function loadPersistedDocument(documentId: string) {
+    const document = persistedDocumentsCache.get(documentId);
+    if (document) {
+      return document;
+    }
+
+    const cdnDocumentId = documentId.replaceAll('~', '/');
+
+    const url = config.cdn.endpoint + '/apps/' + cdnDocumentId;
+    const promise = fetchCache.get(url);
+    if (promise) {
+      return promise;
     }
 
-    return promise;
+    return circuitBreaker.fire({
+      url,
+      documentId,
+    });
   }
 
   return {

packages/libraries/core/src/client/types.ts

@@ -1,6 +1,7 @@
 import type { ExecutionArgs } from 'graphql';
 import type { PromiseOrValue } from 'graphql/jsutils/PromiseOrValue.js';
 import type { AgentOptions } from './agent.js';
+import { CircuitBreakerConfiguration } from './circuit-breaker.js';
 import type { autoDisposeSymbol, hiveClientSymbol } from './client.js';
 import type { SchemaReporter } from './reporting.js';
 import { HiveLogger } from './utils.js';
@@ -318,6 +319,7 @@ export type PersistedDocumentsConfiguration = {
    * used for doing HTTP requests.
    */
   fetch?: typeof fetch;
+  circuitBreaker?: CircuitBreakerConfiguration;
 };
 
 export type AllowArbitraryDocumentsFunction = (context: {