@lodestar/reqresp 1.35.0-dev.fcf8d024ea → 1.35.0-dev.feed916580

package/src/interface.ts

@@ -1,26 +0,0 @@
-//  Request/Response constants
-export enum RespStatus {
-  /**
-   * A normal response follows, with contents matching the expected message schema and encoding specified in the request
-   */
-  SUCCESS = 0,
-  /**
-   * The contents of the request are semantically invalid, or the payload is malformed,
-   * or could not be understood. The response payload adheres to the ErrorMessage schema
-   */
-  INVALID_REQUEST = 1,
-  /**
-   * The responder encountered an error while processing the request. The response payload adheres to the ErrorMessage schema
-   */
-  SERVER_ERROR = 2,
-  /**
-   * The responder does not have requested resource.  The response payload adheres to the ErrorMessage schema (described below). Note: This response code is only valid as a response to BlocksByRange
-   */
-  RESOURCE_UNAVAILABLE = 3,
-  /**
-   * Our node does not have bandwidth to serve requests due to either per-peer quota or total quota.
-   */
-  RATE_LIMITED = 139,
-}
-
-export type RpcResponseStatusError = Exclude<RespStatus, RespStatus.SUCCESS>;

package/src/metrics.ts

@@ -1,95 +0,0 @@
-import {MetricsRegisterExtra} from "@lodestar/utils";
-import {RequestErrorCode} from "./request/errors.js";
-
-export type Metrics = ReturnType<typeof getMetrics>;
-
-/**
- * A collection of metrics used throughout the Gossipsub behaviour.
- */
-export function getMetrics(register: MetricsRegisterExtra) {
-  // Using function style instead of class to prevent having to re-declare all MetricsPrometheus types.
-
-  return {
-    outgoingRequests: register.gauge<{method: string}>({
-      name: "beacon_reqresp_outgoing_requests_total",
-      help: "Counts total requests done per method",
-      labelNames: ["method"],
-    }),
-    outgoingOpenedStreams: register.counter<{method: string}>({
-      name: "beacon_reqresp_outgoing_opened_streams_total",
-      help: "Counts total opened streams per method",
-      labelNames: ["method"],
-    }),
-    outgoingClosedStreams: register.counter<{method: string}>({
-      name: "beacon_reqresp_outgoing_closed_streams_total",
-      help: "Counts total closed streams per method",
-      labelNames: ["method"],
-    }),
-    outgoingRequestRoundtripTime: register.histogram<{method: string}>({
-      name: "beacon_reqresp_outgoing_request_roundtrip_time_seconds",
-      help: "Histogram of outgoing requests round-trip time",
-      labelNames: ["method"],
-      // Spec sets RESP_TIMEOUT = 10 sec
-      buckets: [0.1, 0.2, 0.5, 1, 5, 10, 15, 60],
-    }),
-    outgoingErrors: register.gauge<{method: string}>({
-      name: "beacon_reqresp_outgoing_requests_error_total",
-      help: "Counts total failed requests done per method",
-      labelNames: ["method"],
-    }),
-    outgoingErrorReasons: register.gauge<{reason: RequestErrorCode}>({
-      name: "beacon_reqresp_outgoing_requests_error_reason_total",
-      help: "Count total outgoing request errors by reason",
-      labelNames: ["reason"],
-    }),
-    incomingRequests: register.gauge<{method: string}>({
-      name: "beacon_reqresp_incoming_requests_total",
-      help: "Counts total responses handled per method",
-      labelNames: ["method"],
-    }),
-    incomingOpenedStreams: register.counter<{method: string}>({
-      name: "beacon_reqresp_incoming_opened_streams_total",
-      help: "Counts total incoming opened streams per method",
-      labelNames: ["method"],
-    }),
-    incomingClosedStreams: register.counter<{method: string}>({
-      name: "beacon_reqresp_incoming_closed_streams_total",
-      help: "Counts total incoming closed streams per method",
-      labelNames: ["method"],
-    }),
-    incomingRequestHandlerTime: register.histogram<{method: string}>({
-      name: "beacon_reqresp_incoming_request_handler_time_seconds",
-      help: "Histogram of incoming requests internal handling time",
-      labelNames: ["method"],
-      // Spec sets RESP_TIMEOUT = 10 sec
-      buckets: [0.1, 0.2, 0.5, 1, 5, 10],
-    }),
-    incomingErrors: register.gauge<{method: string}>({
-      name: "beacon_reqresp_incoming_requests_error_total",
-      help: "Counts total failed responses handled per method",
-      labelNames: ["method"],
-    }),
-    outgoingResponseTTFB: register.histogram<{method: string}>({
-      name: "beacon_reqresp_outgoing_response_ttfb_seconds",
-      help: "Time to first byte (TTFB) for outgoing responses",
-      labelNames: ["method"],
-      // Spec sets TTFB_TIMEOUT = 5 sec
-      buckets: [0.1, 1, 5],
-    }),
-    incomingResponseTTFB: register.histogram<{method: string}>({
-      name: "beacon_reqresp_incoming_response_ttfb_seconds",
-      help: "Time to first byte (TTFB) for incoming responses",
-      labelNames: ["method"],
-      // Spec sets TTFB_TIMEOUT = 5 sec
-      buckets: [0.1, 1, 5],
-    }),
-    dialErrors: register.gauge({
-      name: "beacon_reqresp_dial_errors_total",
-      help: "Count total dial errors",
-    }),
-    selfRateLimiterPeerCount: register.gauge({
-      name: "beacon_reqresp_self_rate_limiter_peer_count",
-      help: "Count of peers tracked by the self rate limiter",
-    }),
-  };
-}

package/src/rate_limiter/ReqRespRateLimiter.ts

@@ -1,107 +0,0 @@
-import {PeerId} from "@libp2p/interface";
-import {InboundRateLimitQuota, ReqRespRateLimiterOpts} from "../types.js";
-import {RateLimiterGRCA} from "./rateLimiterGRCA.js";
-
-/** Sometimes a peer request comes AFTER libp2p disconnect event, check for such peers every 10 minutes */
-const CHECK_DISCONNECTED_PEERS_INTERVAL_MS = 10 * 60 * 1000;
-
-/** Peers don't request us for 5 mins are considered disconnected */
-const DISCONNECTED_TIMEOUT_MS = 5 * 60 * 1000;
-
-type ProtocolID = string;
-
-export class ReqRespRateLimiter {
-  private readonly rateLimitersPerPeer = new Map<ProtocolID, RateLimiterGRCA<string>>();
-  private readonly rateLimitersTotal = new Map<ProtocolID, RateLimiterGRCA<null>>();
-  /** Interval to check lastSeenMessagesByPeer */
-  private cleanupInterval: NodeJS.Timeout | undefined = undefined;
-  private rateLimitMultiplier: number;
-  /** Periodically check this to remove tracker of disconnected peers */
-  private lastSeenRequestsByPeer: Map<string, number>;
-
-  constructor(private readonly opts?: ReqRespRateLimiterOpts) {
-    this.rateLimitMultiplier = opts?.rateLimitMultiplier ?? 1;
-    this.lastSeenRequestsByPeer = new Map();
-  }
-
-  get enabled(): boolean {
-    return this.rateLimitMultiplier > 0;
-  }
-
-  setRateLimits(protocolID: ProtocolID, rateLimits: InboundRateLimitQuota): void {
-    if (!this.enabled) {
-      return;
-    }
-
-    if (rateLimits.byPeer) {
-      this.rateLimitersPerPeer.set(
-        protocolID,
-        RateLimiterGRCA.fromQuota<string>({
-          quotaTimeMs: rateLimits.byPeer.quotaTimeMs,
-          quota: rateLimits.byPeer.quota * this.rateLimitMultiplier,
-        })
-      );
-    }
-
-    if (rateLimits.total) {
-      this.rateLimitersTotal.set(
-        protocolID,
-        RateLimiterGRCA.fromQuota<null>({
-          quotaTimeMs: rateLimits.total.quotaTimeMs,
-          quota: rateLimits.total.quota * this.rateLimitMultiplier,
-        })
-      );
-    }
-  }
-
-  allows(peerId: PeerId, protocolID: string, requestCount: number): boolean {
-    if (!this.enabled) {
-      return true;
-    }
-
-    const peerIdStr = peerId.toString();
-    this.lastSeenRequestsByPeer.set(peerIdStr, Date.now());
-
-    const byPeer = this.rateLimitersPerPeer.get(protocolID);
-    const total = this.rateLimitersTotal.get(protocolID);
-
-    if ((byPeer && !byPeer.allows(peerIdStr, requestCount)) || (total && !total.allows(null, requestCount))) {
-      this.opts?.onRateLimit?.(peerId, protocolID);
-      return false;
-    }
-
-    return true;
-  }
-
-  prune(peerId: PeerId): void {
-    const peerIdStr = peerId.toString();
-    this.pruneByPeerIdStr(peerIdStr);
-  }
-
-  start(): void {
-    this.cleanupInterval = setInterval(this.checkDisconnectedPeers.bind(this), CHECK_DISCONNECTED_PEERS_INTERVAL_MS);
-  }
-
-  stop(): void {
-    if (this.cleanupInterval !== undefined) {
-      clearInterval(this.cleanupInterval);
-    }
-  }
-
-  private pruneByPeerIdStr(peerIdStr: string): void {
-    // Check for every method and version to cleanup
-    for (const method of this.rateLimitersPerPeer.values()) {
-      method.pruneByKey(peerIdStr);
-    }
-    this.lastSeenRequestsByPeer.delete(peerIdStr);
-  }
-
-  private checkDisconnectedPeers(): void {
-    const now = Date.now();
-    for (const [peerIdStr, lastSeenTime] of this.lastSeenRequestsByPeer.entries()) {
-      if (now - lastSeenTime >= DISCONNECTED_TIMEOUT_MS) {
-        this.pruneByPeerIdStr(peerIdStr);
-      }
-    }
-  }
-}

package/src/rate_limiter/rateLimiterGRCA.ts

@@ -1,92 +0,0 @@
-type MiliSeconds = number;
-
-export interface RateLimiterQuota {
-  /** How often are `max_tokens` fully replenished. */
-  quotaTimeMs: MiliSeconds;
-  /** Token limit. This translates on how large can an instantaneous batch of tokens be. */
-  quota: number;
-}
-
-/**
- * Generic Cell Rate Algorithm is a leaky bucket-type scheduling algorithm.
- *
- * Most rate-limit implementations are either time-bucket or leaky-bucket based. The time-bucket requires the storage
- * of two values and does not enforce a rate, while the leaky-bucket approach requires a separate process to
- * continually refill the bucket. GCRA only storing a value (the TAT) while still being simple. GCRA may be rarely
- * used because of its perceived complexity.
- *
- * GCRA aims to limit requests to `R = L/P`, where this implementation sets `L = 1` for simplicity. The target rate
- * then is `R = 1/P` so request separated by at least `P` are not limited. Define the Theoretical Arrival Time (TAT)
- * of the next request to be equal
- */
-export class RateLimiterGRCA<Key> {
-  /** Time when the bucket will be full for each peer. TAT (theoretical arrival time) from GCRA */
-  private readonly tatPerKey = new Map<Key, MiliSeconds>();
-  private readonly startTimeMs = Date.now();
-
-  constructor(
-    /** After how long is the bucket considered full via replenishing 1T every `t`. */
-    private readonly msPerBucket: MiliSeconds,
-    /** How often is 1 token replenished */
-    private readonly msPerToken: MiliSeconds
-  ) {}
-
-  static fromQuota<Key>(quota: RateLimiterQuota): RateLimiterGRCA<Key> {
-    if (quota.quota === 0) {
-      throw Error("Max number of tokens should be positive");
-    }
-    const msPerBucket = quota.quotaTimeMs;
-    if (msPerBucket === 0) {
-      throw Error("Replenish time must be positive");
-    }
-    const msPerToken = msPerBucket / quota.quota;
-    return new RateLimiterGRCA(msPerBucket, msPerToken);
-  }
-
-  allows(key: Key, tokens: number): boolean {
-    if (tokens <= 0) {
-      throw new Error(`Token value should always be positive. Given: ${tokens}.`);
-    }
-
-    const msSinceStart = Date.now() - this.startTimeMs;
-
-    /** how long does it take to replenish these tokens */
-    const additionalTime = this.msPerToken * tokens;
-
-    if (additionalTime > this.msPerBucket) {
-      // the time required to process this amount of tokens is longer than the time that makes the bucket full.
-      return false;
-    }
-
-    // If the key is new, we consider their bucket full (which means, their request will be allowed)
-    let resetTimeForKey = this.tatPerKey.get(key);
-    if (resetTimeForKey === undefined) {
-      resetTimeForKey = msSinceStart;
-      this.tatPerKey.set(key, resetTimeForKey);
-    }
-
-    // check how soon could the request be made
-    const earliestTime = resetTimeForKey + additionalTime - this.msPerBucket;
-    if (msSinceStart < earliestTime) {
-      return false;
-    }
-
-    // calculate the new TAT
-    this.tatPerKey.set(key, Math.max(msSinceStart, resetTimeForKey) + additionalTime);
-    return true;
-  }
-
-  /** Removes keys for which their bucket is full by `time_limit` */
-  pruneByTime(timeLimit: MiliSeconds): void {
-    for (const entry of this.tatPerKey.entries()) {
-      // remove those for which tat < lim
-      if (entry[1] < timeLimit) {
-        this.tatPerKey.delete(entry[0]);
-      }
-    }
-  }
-
-  pruneByKey(key: Key): void {
-    this.tatPerKey.delete(key);
-  }
-}

package/src/rate_limiter/selfRateLimiter.ts

@@ -1,112 +0,0 @@
-import {Logger, MapDef} from "@lodestar/utils";
-
-type PeerIdStr = string;
-type ProtocolID = string;
-/** https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/p2p-interface.md#constants */
-const MAX_CONCURRENT_REQUESTS = 2;
-
-/** Sometimes a peer request comes AFTER libp2p disconnect event, check for such peers every 2 minutes */
-export const CHECK_DISCONNECTED_PEERS_INTERVAL_MS = 2 * 60 * 1000;
-
-/** Given PING_INTERVAL constants of 15s/20s, we consider a peer is disconnected if there is no request in 1 minute */
-const DISCONNECTED_TIMEOUT_MS = 60 * 1000;
-
-/**
- * Timeout to consider a request is no longer in progress
- * this is to cover the case where `requestCompleted()` is not called due to unexpected errors
- * for example https://github.com/ChainSafe/lodestar/issues/8256
- **/
-export const REQUEST_TIMEOUT_MS = 30 * 1000;
-
-type RequestId = number;
-type RequestIdMs = number;
-
-/**
- * Simple rate limiter that allows a maximum of 2 concurrent requests per protocol per peer.
- * The consumer should either prevent requests from being sent when the limit is reached or handle the case when the request is not allowed.
- */
-export class SelfRateLimiter {
-  private readonly rateLimitersPerPeer: MapDef<PeerIdStr, MapDef<ProtocolID, Map<RequestId, RequestIdMs>>>;
-  /**
-   * It's not convenient to handle a peer disconnected event so we track the last seen requests by peer.
-   * This is the same design to `ReqRespRateLimiter`.
-   **/
-  private lastSeenRequestsByPeer: Map<string, number>;
-  /** Interval to check lastSeenMessagesByPeer */
-  private cleanupInterval: NodeJS.Timeout | undefined = undefined;
-
-  constructor(private readonly logger?: Logger) {
-    this.rateLimitersPerPeer = new MapDef<PeerIdStr, MapDef<ProtocolID, Map<RequestId, RequestIdMs>>>(
-      () => new MapDef<ProtocolID, Map<RequestId, RequestIdMs>>(() => new Map())
-    );
-    this.lastSeenRequestsByPeer = new Map();
-  }
-
-  start(): void {
-    this.cleanupInterval = setInterval(this.checkDisconnectedPeers.bind(this), CHECK_DISCONNECTED_PEERS_INTERVAL_MS);
-  }
-
-  stop(): void {
-    if (this.cleanupInterval !== undefined) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = undefined;
-    }
-  }
-
-  /**
-   * called before we send a request to a peer.
-   */
-  allows(peerId: PeerIdStr, protocolId: ProtocolID, requestId: RequestId): boolean {
-    const now = Date.now();
-    const peerRateLimiter = this.rateLimitersPerPeer.getOrDefault(peerId);
-    const trackedRequests = peerRateLimiter.getOrDefault(protocolId);
-    this.lastSeenRequestsByPeer.set(peerId, now);
-
-    let inProgressRequests = 0;
-    for (const [trackedRequestId, trackedRequestTimeMs] of trackedRequests.entries()) {
-      if (trackedRequestTimeMs + REQUEST_TIMEOUT_MS <= now) {
-        // request timed out, remove it
-        trackedRequests.delete(trackedRequestId);
-        this.logger?.debug("SelfRateLimiter: request timed out, removing it", {
-          requestId: trackedRequestId,
-          requestTime: trackedRequestTimeMs,
-          peerId,
-          protocolId,
-        });
-      } else {
-        inProgressRequests++;
-      }
-    }
-
-    if (inProgressRequests >= MAX_CONCURRENT_REQUESTS) {
-      return false;
-    }
-
-    trackedRequests.set(requestId, now);
-    return true;
-  }
-
-  /**
-   * called when a request to a peer is completed, regardless of success or failure.
-   * This should NOT be called when the request was not allowed
-   */
-  requestCompleted(peerId: PeerIdStr, protocolId: ProtocolID, requestId: RequestId): void {
-    const peerRateLimiter = this.rateLimitersPerPeer.getOrDefault(peerId);
-    const trackedRequests = peerRateLimiter.getOrDefault(protocolId);
-    trackedRequests.delete(requestId);
-  }
-
-  getPeerCount(): number {
-    return this.rateLimitersPerPeer.size;
-  }
-
-  private checkDisconnectedPeers(): void {
-    const now = Date.now();
-    for (const [peerIdStr, lastSeenTime] of this.lastSeenRequestsByPeer.entries()) {
-      if (now - lastSeenTime >= DISCONNECTED_TIMEOUT_MS) {
-        this.rateLimitersPerPeer.delete(peerIdStr);
-        this.lastSeenRequestsByPeer.delete(peerIdStr);
-      }
-    }
-  }
-}

package/src/request/errors.ts

@@ -1,119 +0,0 @@
-import {LodestarError, LodestarErrorObject} from "@lodestar/utils";
-import {RespStatus, RpcResponseStatusError} from "../interface.js";
-import {ResponseError} from "../response/index.js";
-
-export enum RequestErrorCode {
-  // Declaring specific values of RpcResponseStatusError for error clarity downstream
-  /** `<response_chunk>` had `<result>` === INVALID_REQUEST */
-  INVALID_REQUEST = "REQUEST_ERROR_INVALID_REQUEST",
-  INVALID_RESPONSE_SSZ = "REQUEST_ERROR_INVALID_RESPONSE_SSZ",
-  /** `<response_chunk>` had `<result>` === SERVER_ERROR */
-  SERVER_ERROR = "REQUEST_ERROR_SERVER_ERROR",
-  /** `<response_chunk>` had `<result>` === RESOURCE_UNAVAILABLE */
-  RESOURCE_UNAVAILABLE = "RESOURCE_UNAVAILABLE_ERROR",
-  /** `<response_chunk>` had a `<result>` not known in the current spec */
-  UNKNOWN_ERROR_STATUS = "REQUEST_ERROR_UNKNOWN_ERROR_STATUS",
-  /** Could not open a stream with peer before DIAL_TIMEOUT */
-  DIAL_TIMEOUT = "REQUEST_ERROR_DIAL_TIMEOUT",
-  /** Error opening a stream with peer */
-  DIAL_ERROR = "REQUEST_ERROR_DIAL_ERROR",
-  /** Reponder did not close write stream before REQUEST_TIMEOUT */
-  REQUEST_TIMEOUT = "REQUEST_ERROR_REQUEST_TIMEOUT",
-  /** Error when sending request to responder */
-  REQUEST_ERROR = "REQUEST_ERROR_REQUEST_ERROR",
-  /** Reponder did not deliver a full reponse before max maxTotalResponseTimeout() */
-  RESPONSE_TIMEOUT = "REQUEST_ERROR_RESPONSE_TIMEOUT",
-  /** A single-response method returned 0 chunks */
-  EMPTY_RESPONSE = "REQUEST_ERROR_EMPTY_RESPONSE",
-  /** Time to first byte timeout */
-  TTFB_TIMEOUT = "REQUEST_ERROR_TTFB_TIMEOUT",
-  /** Timeout between `<response_chunk>` exceed */
-  RESP_TIMEOUT = "REQUEST_ERROR_RESP_TIMEOUT",
-  /** Request rate limited */
-  REQUEST_RATE_LIMITED = "REQUEST_ERROR_RATE_LIMITED",
-  /** Request self rate limited */
-  REQUEST_SELF_RATE_LIMITED = "REQUEST_ERROR_SELF_RATE_LIMITED",
-  /** Response rate limited */
-  RESP_RATE_LIMITED = "RESPONSE_ERROR_RATE_LIMITED",
-  /** For malformed SSZ (metadata) responses */
-  SSZ_OVER_MAX_SIZE = "SSZ_SNAPPY_ERROR_OVER_SSZ_MAX_SIZE",
-}
-
-type RequestErrorType =
-  | {code: RequestErrorCode.INVALID_REQUEST; errorMessage: string}
-  | {code: RequestErrorCode.INVALID_RESPONSE_SSZ; errorMessage: string}
-  | {code: RequestErrorCode.SERVER_ERROR; errorMessage: string}
-  | {code: RequestErrorCode.RESOURCE_UNAVAILABLE; errorMessage: string}
-  | {code: RequestErrorCode.UNKNOWN_ERROR_STATUS; status: RpcResponseStatusError; errorMessage: string}
-  | {code: RequestErrorCode.DIAL_TIMEOUT}
-  | {code: RequestErrorCode.DIAL_ERROR; error: Error}
-  | {code: RequestErrorCode.REQUEST_TIMEOUT}
-  | {code: RequestErrorCode.REQUEST_ERROR; error: Error}
-  | {code: RequestErrorCode.EMPTY_RESPONSE}
-  | {code: RequestErrorCode.TTFB_TIMEOUT}
-  | {code: RequestErrorCode.RESP_TIMEOUT}
-  | {code: RequestErrorCode.REQUEST_RATE_LIMITED}
-  | {code: RequestErrorCode.REQUEST_SELF_RATE_LIMITED}
-  | {code: RequestErrorCode.RESP_RATE_LIMITED}
-  | {code: RequestErrorCode.SSZ_OVER_MAX_SIZE};
-
-export const REQUEST_ERROR_CLASS_NAME = "RequestError";
-
-export class RequestError extends LodestarError<RequestErrorType> {
-  constructor(type: RequestErrorType, message?: string, stack?: string) {
-    super(type, message ?? renderErrorMessage(type), stack);
-  }
-
-  static fromObject(obj: LodestarErrorObject): RequestError {
-    if (obj.className !== "RequestError") {
-      throw new Error(`Expected className to be RequestError, but got ${obj.className}`);
-    }
-
-    return new RequestError(obj.type as RequestErrorType, obj.message, obj.stack);
-  }
-}
-
-/**
- * Parse response status errors into detailed request errors for each status code for easier debugging
- */
-export function responseStatusErrorToRequestError(e: ResponseError): RequestErrorType {
-  const {errorMessage, status} = e;
-  // rate limited error from clients have different status, for example: lighthouse responds with 139, teku responds with 1
-  // but all of them has "rate limit" in the error message
-  // refer to https://github.com/ChainSafe/lodestar/issues/8065#issuecomment-3157266196
-  const errorMessageLowercase = errorMessage.toLowerCase();
-  if (errorMessageLowercase.includes("rate limit")) {
-    return {code: RequestErrorCode.RESP_RATE_LIMITED};
-  }
-
-  // Grandine may return this without standard RespStatus, see https://github.com/ChainSafe/lodestar/issues/8110
-  if (errorMessageLowercase.includes("wait ")) {
-    return {code: RequestErrorCode.RESP_TIMEOUT};
-  }
-
-  switch (status) {
-    case RespStatus.INVALID_REQUEST:
-      return {code: RequestErrorCode.INVALID_REQUEST, errorMessage};
-    case RespStatus.SERVER_ERROR:
-      return {code: RequestErrorCode.SERVER_ERROR, errorMessage};
-    case RespStatus.RESOURCE_UNAVAILABLE:
-      return {code: RequestErrorCode.RESOURCE_UNAVAILABLE, errorMessage};
-    default:
-      return {code: RequestErrorCode.UNKNOWN_ERROR_STATUS, errorMessage, status};
-  }
-}
-
-/**
- * Render responder's errorMessage directly in main's error.message for easier debugging
- */
-function renderErrorMessage(type: RequestErrorType): string | undefined {
-  switch (type.code) {
-    case RequestErrorCode.INVALID_REQUEST:
-    case RequestErrorCode.SERVER_ERROR:
-    case RequestErrorCode.RESOURCE_UNAVAILABLE:
-    case RequestErrorCode.UNKNOWN_ERROR_STATUS:
-      return `${type.code}: ${type.errorMessage}`;
-    default:
-      return type.code;
-  }
-}