@stream-io/video-client 1.39.2 → 1.40.0

package/src/rpc/createClient.ts

@@ -40,9 +40,49 @@ export const withHeaders = (
   };
 };
 
+export const TIMEOUT_SYMBOL = '@@stream-io/timeout';
+
+export const withTimeout = (
+  timeoutMs: number,
+  trace?: Trace,
+): RpcInterceptor => {
+  const scheduleTimeout = (methodName: string) => {
+    const controller = new AbortController();
+    // aborts with specially crafted error that can be reliably recognized by
+    // @protobuf-ts/twirp-transport and our internal retry logic.
+    // https://github.com/timostamm/protobuf-ts/blob/657e64e80009e503e94f608fda423fbcbf4fb5a7/packages/twirp-transport/src/twirp-transport.ts#L102-L107
+    const timeoutId = setTimeout(() => {
+      trace?.(`${methodName}Timeout`, [timeoutMs]);
+      const error = new Error(TIMEOUT_SYMBOL);
+      error.name = 'AbortError';
+      controller.abort(error);
+    }, timeoutMs);
+    return [controller.signal, () => clearTimeout(timeoutId)] as const;
+  };
+
+  return {
+    interceptUnary(
+      next: NextUnaryFn,
+      method: MethodInfo,
+      input: object,
+      options: RpcOptions,
+    ): UnaryCall {
+      // respect external abort signals if provided
+      if (options.abort) return next(method, input, options);
+
+      // set up a custom abort signal for the RPC call
+      const [signal, cancel] = scheduleTimeout(method.name);
+      const invocation = next(method, input, { ...options, abort: signal });
+      invocation.then(cancel, cancel);
+
+      return invocation;
+    },
+  };
+};
+
 export const withRequestLogger = (
   logger: ScopedLogger,
-  level: LogLevel,
+  level: LogLevel = 'trace',
 ): RpcInterceptor => {
   return {
     interceptUnary: (
@@ -78,18 +118,24 @@ export const withRequestTracer = (trace: Trace): RpcInterceptor => {
       input: object,
       options: RpcOptions,
     ): UnaryCall {
-      const name = method.name as RpcMethodName;
-      if (exclusions.has(name)) return next(method, input, options);
+      const methodName = method.name as RpcMethodName;
+      if (exclusions.has(methodName)) return next(method, input, options);
+
+      const { invocationMeta: { attempt = 0 } = {} } = options;
+      const traceName =
+        attempt === 0 ? methodName : `${methodName}(${attempt})`;
+      trace(traceName, input);
 
-      trace(name, input);
       const unaryCall = next(method, input, options);
       unaryCall.then(
         (invocation) => {
           const response = invocation.response as SfuResponseWithError;
-          if (response.error) traceError(name, input, response.error);
-          if (responseInclusions.has(name)) trace(`${name}Response`, response);
+          if (response.error) traceError(traceName, input, response.error);
+          if (responseInclusions.has(methodName)) {
+            trace(`${traceName}Response`, response);
+          }
         },
-        (error) => traceError(name, input, error),
+        (error) => traceError(methodName, input, error),
       );
       return unaryCall;
     },

package/src/rpc/retryable.ts

@@ -7,6 +7,8 @@ import { TwirpErrorCode } from '@protobuf-ts/twirp-transport';
 import { retryInterval, sleep } from '../coordinator/connection/utils';
 import { Error as SfuError } from '../gen/video/sfu/models/models';
 import { videoLoggerSystem } from '../logger';
+import { TIMEOUT_SYMBOL } from './createClient';
+import type { RpcInvocationMeta } from './types';
 
 /**
  * An internal interface which asserts that "retryable" SFU responses
@@ -28,26 +30,30 @@ export interface SfuResponseWithError {
  *
  * @param rpc the closure around the RPC call to execute.
  * @param signal the signal to abort the RPC call and retries loop.
+ * @param maxRetries the maximum number of retries to perform. Defaults to `Number.POSITIVE_INFINITY`.
  */
 export const retryable = async <
   I extends object,
   O extends SfuResponseWithError,
 >(
-  rpc: () => UnaryCall<I, O>,
+  rpc: (invocationMeta: RpcInvocationMeta) => UnaryCall<I, O>,
   signal?: AbortSignal,
+  maxRetries = Number.POSITIVE_INFINITY,
 ): Promise<FinishedUnaryCall<I, O>> => {
   let attempt = 0;
   let result: FinishedUnaryCall<I, O> | undefined = undefined;
   do {
     if (attempt > 0) await sleep(retryInterval(attempt));
     try {
-      result = await rpc();
+      result = await rpc({ attempt });
     } catch (err) {
       const isRequestCancelled =
         err instanceof RpcError &&
+        err.message !== TIMEOUT_SYMBOL &&
         err.code === TwirpErrorCode[TwirpErrorCode.cancelled];
       const isAborted = signal?.aborted ?? false;
       if (isRequestCancelled || isAborted) throw err;
+      if (attempt + 1 >= maxRetries) throw err;
       videoLoggerSystem
         .getLogger('sfu-client', { tags: ['rpc'] })
         .debug(`rpc failed (${attempt})`, err);

package/src/rpc/types.ts

@@ -0,0 +1,11 @@
+export type RpcInvocationMeta = {
+  attempt: number;
+};
+
+declare module '@protobuf-ts/runtime-rpc' {
+  // instead of casting, we extend the default interface with
+  // an additional payload provided by our `retryable` implementation
+  interface RpcOptions {
+    invocationMeta?: RpcInvocationMeta;
+  }
+}