Relay runtime: add a new 'log' interface (#41807)

types/relay-runtime/index.d.ts

@@ -24,7 +24,6 @@ export {
 } from './lib/mutations/RelayDeclarativeMutationConfig';
 export { OptimisticMutationConfig } from './lib/mutations/applyOptimisticMutation';
 export { MutationConfig, MutationParameters } from './lib/mutations/commitMutation';
-export { RelayNetworkLog, LoggerTransactionConfig } from './lib/network/RelayNetworkLoggerTransaction';
 export {
     ExecuteFunction,
     FetchFunction,
@@ -38,7 +37,6 @@ export {
     UploadableMap,
 } from './lib/network/RelayNetworkTypes';
 export { ObservableFromValue, Observer, Subscribable, Subscription } from './lib/network/RelayObservable';
-export { GraphiQLPrinter, NetworkLogger } from './lib/network/createRelayNetworkLogger';
 export {
     GraphQLTaggedNode,
     graphql,
@@ -70,8 +68,6 @@ export {
     FragmentReference,
     FragmentSpecResolver,
     HandleFieldPayload,
-    Logger,
-    LoggerProvider,
     MissingFieldHandler,
     ModuleImportPointer,
     NormalizationSelector,
@@ -197,8 +193,6 @@ export { getRelayHandleKey } from './lib/util/getRelayHandleKey';
 // INTERNAL-ONLY
 export { RelayConcreteNode } from './lib/util/RelayConcreteNode';
 export { RelayFeatureFlags } from './lib/util/RelayFeatureFlags';
-export { RelayNetworkLoggerTransaction } from './lib/network/RelayNetworkLoggerTransaction';
-export { createRelayNetworkLogger } from './lib/network/createRelayNetworkLogger';
 export { deepFreeze } from './lib/util/deepFreeze';
 
 /**

types/relay-runtime/lib/network/RelayNetworkLoggerTransaction.d.ts

@@ -1,31 +0,0 @@
-import { RequestParameters } from '../util/RelayConcreteNode';
-import { Variables, CacheConfig } from '../util/RelayRuntimeTypes';
-import { UploadableMap, GraphQLResponse } from './RelayNetworkTypes';
-
-export interface RelayNetworkLog {
-    label: string;
-    values: ReadonlyArray<any>;
-}
-
-export interface LoggerTransactionConfig {
-    request: RequestParameters;
-    variables: Variables;
-    cacheConfig: CacheConfig;
-    uploadables?: UploadableMap;
-}
-
-export class RelayNetworkLoggerTransaction {
-    constructor(config: LoggerTransactionConfig);
-    addLog(label: string, ...values: any[]): void;
-    commitLogs(error: Error, payload: GraphQLResponse, status?: string): void;
-    flushLogs(error: Error, payload: GraphQLResponse, status?: string): void;
-    markCommitted(): void;
-    getCacheConfig(): CacheConfig;
-    getIdentifier(): string;
-    getLogsToPrint(): RelayNetworkLog[];
-    getRequest(): RequestParameters;
-    getUploadables(): UploadableMap;
-    getVariables(): Variables;
-    timerStart(): void;
-    timerEnd(): void;
-}

types/relay-runtime/lib/network/createRelayNetworkLogger.d.ts

@@ -1,14 +0,0 @@
-import { RelayNetworkLoggerTransaction } from './RelayNetworkLoggerTransaction';
-import { RequestParameters } from '../util/RelayConcreteNode';
-import { Variables } from '../util/RelayRuntimeTypes';
-import { FetchFunction, SubscribeFunction } from './RelayNetworkTypes';
-
-export type GraphiQLPrinter = (request: RequestParameters, variables: Variables) => string;
-export interface NetworkLogger {
-    wrapFetch: (fetch: FetchFunction, graphiQLPrinter?: GraphiQLPrinter) => FetchFunction;
-    wrapSubscribe: (subscribe: SubscribeFunction, graphiQLPrinter?: GraphiQLPrinter) => SubscribeFunction;
-}
-
-declare function createRelayNetworkLogger(LoggerTransaction: typeof RelayNetworkLoggerTransaction): NetworkLogger;
-
-export { createRelayNetworkLogger };

types/relay-runtime/lib/store/RelayModernEnvironment.d.ts

@@ -5,13 +5,11 @@ import {
     Store,
     MissingFieldHandler,
     OperationTracker,
-    LoggerProvider,
-    Logger,
+    LogFunction,
     OptimisticUpdateFunction,
     OperationAvailability,
     OperationDescriptor,
     SelectorStoreUpdater,
-    NormalizationSelector,
     StoreUpdater,
     SingularReaderSelector,
     Snapshot,
@@ -21,20 +19,19 @@ import {
 import { Network, PayloadData, GraphQLResponse, UploadableMap } from '../network/RelayNetworkTypes';
 import { TaskScheduler } from './RelayModernQueryExecutor';
 import { RelayOperationTracker } from './RelayOperationTracker';
-import { LoggerTransactionConfig } from '../network/RelayNetworkLoggerTransaction';
 import { Disposable, CacheConfig } from '../util/RelayRuntimeTypes';
 import { RelayObservable } from '../network/RelayObservable';
 
 export interface EnvironmentConfig {
     readonly configName?: string;
     readonly handlerProvider?: HandlerProvider | null;
+    readonly log?: LogFunction | null;
     readonly operationLoader?: OperationLoader | null;
     readonly network: Network;
     readonly scheduler?: TaskScheduler | null;
     readonly store: Store;
     readonly missingFieldHandlers?: ReadonlyArray<MissingFieldHandler> | null;
     readonly operationTracker?: OperationTracker | null;
-    readonly loggerProvider?: LoggerProvider | null;
 }
 
 export class RelayModernEnvironment implements Environment {
@@ -43,7 +40,6 @@ export class RelayModernEnvironment implements Environment {
     getStore(): Store;
     getNetwork(): Network;
     getOperationTracker(): RelayOperationTracker;
-    getLogger(config: LoggerTransactionConfig): Logger | null | undefined;
     applyUpdate(optimisticUpdate: OptimisticUpdateFunction): Disposable;
     revertUpdate(update: OptimisticUpdateFunction): void;
     replaceUpdate(update: OptimisticUpdateFunction, newUpdate: OptimisticUpdateFunction): void;

types/relay-runtime/lib/store/RelayStoreTypes.d.ts

@@ -15,7 +15,6 @@ import {
     ConnectionInternalEvent,
     ConnectionID,
 } from './RelayConnection';
-import { LoggerTransactionConfig } from '../network/RelayNetworkLoggerTransaction';
 import { PayloadData, Network, UploadableMap, PayloadError, GraphQLResponse } from '../network/RelayNetworkTypes';
 import { RelayObservable } from '../network/RelayObservable';
 import { RelayOperationTracker } from './RelayOperationTracker';
@@ -395,15 +394,74 @@ export interface RecordSourceSelectorProxy<T = {}> extends RecordSourceProxy {
     insertConnectionEdge_UNSTABLE(connectionID: ConnectionID, args: Variables, edge: RecordProxy): void;
 }
 
-export interface Logger {
-    log(message: string, ...values: unknown[]): void;
-    flushLogs(): void;
+interface OperationDescriptor {
+    readonly fragment: SingularReaderSelector;
+    readonly request: RequestDescriptor;
+    readonly root: NormalizationSelector;
 }
 
-export interface LoggerProvider {
-    getLogger(config: LoggerTransactionConfig): Logger;
+interface LogEventQueryResourceFetch {
+    readonly name: 'queryresource.fetch';
+    readonly operation: OperationDescriptor;
+    // FetchPolicy from relay-experimental
+    readonly fetchPolicy: string;
+    // RenderPolicy from relay-experimental
+    readonly renderPolicy: string;
+    readonly queryAvailability: OperationAvailability;
+    readonly shouldFetch: boolean;
 }
 
+interface LogEventExecuteInfo {
+    readonly name: 'execute.info';
+    readonly transactionID: number;
+    readonly info: unknown;
+}
+
+interface LogEventExecuteStart {
+    readonly name: 'execute.start';
+    readonly transactionID: number;
+    readonly params: {
+        // RequestParameters type
+        readonly name: string;
+        readonly operationKind: string;
+        readonly text: string;
+    };
+    readonly variables: object;
+}
+
+interface LogEventExecuteNext {
+    readonly name: 'execute.next';
+    readonly transactionID: number;
+    readonly response: unknown;
+}
+
+interface LogEventExecuteError {
+    readonly name: 'execute.error';
+    readonly transactionID: number;
+    readonly error: Error;
+}
+
+interface LogEventExecuteComplete {
+    readonly name: 'execute.complete';
+    readonly transactionID: number;
+}
+
+interface LogEventExecuteUnsubscribe {
+    readonly name: 'execute.unsubscribe';
+    readonly transactionID: number;
+}
+
+type LogEvent =
+    | LogEventQueryResourceFetch
+    | LogEventExecuteInfo
+    | LogEventExecuteStart
+    | LogEventExecuteNext
+    | LogEventExecuteError
+    | LogEventExecuteComplete
+    | LogEventExecuteUnsubscribe;
+
+export type LogFunction = (logEvent: LogEvent) => void;
+
 /**
  * The public API of Relay core. Represents an encapsulated environment with its
  * own in-memory cache.
@@ -467,11 +525,6 @@ export interface Environment {
      */
     getStore(): Store;
 
-    /**
-     * Get an instance of a logger
-     */
-    getLogger(config: LoggerTransactionConfig): Logger | null | undefined;
-
     /**
      * Returns the environment specific OperationTracker.
      */

types/relay-runtime/relay-runtime-tests.tsx

@@ -10,10 +10,8 @@ import {
     RecordProxy,
     RecordSource,
     RecordSourceSelectorProxy,
-    RelayNetworkLoggerTransaction,
     Store,
     commitLocalUpdate,
-    createRelayNetworkLogger,
 } from 'relay-runtime';
 
 const source = new RecordSource();
@@ -36,10 +34,8 @@ function fetchQuery(operation: any, variables: { [key: string]: string }, cacheC
     });
 }
 
-const RelayNetworkLogger = createRelayNetworkLogger(RelayNetworkLoggerTransaction);
-
 // Create a network layer from the fetch function
-const network = Network.create(RelayNetworkLogger.wrapFetch(fetchQuery));
+const network = Network.create(fetchQuery);
 
 // Create a cache for storing query responses
 const cache = new QueryResponseCache({ size: 250, ttl: 60000 });
@@ -81,6 +77,19 @@ const environment = new Environment({
             kind: 'linked',
         },
     ],
+    log: (logEvent) => {
+        switch (logEvent.name) {
+            case 'execute.start':
+            case 'execute.next':
+            case 'execute.error':
+            case 'execute.info':
+            case 'execute.complete':
+            case 'execute.unsubscribe':
+            case 'queryresource.fetch':
+            default:
+                break;
+        }
+    }
 });
 
 // ~~~~~~~~~~~~~~~~~~~~~