@oneuptime/common 14.0.7 → 14.0.8

package/UI/Components/Forms/ModelForm.tsx

@@ -39,6 +39,7 @@ import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/Database
 import FileModel from "../../../Models/DatabaseModels/DatabaseBaseModel/FileModel";
 import Label from "../../../Models/DatabaseModels/Label";
 import URL from "../../../Types/API/URL";
+import HTTPErrorResponse from "../../../Types/API/HTTPErrorResponse";
 import { ColumnAccessControl } from "../../../Types/BaseDatabase/AccessControl";
 import { Black, VeryLightGray } from "../../../Types/BrandColors";
 import Color from "../../../Types/Color";
@@ -61,11 +62,39 @@ import React, { MutableRefObject, ReactElement, useRef, useState } from "react";
 import useAsyncEffect from "use-async-effect";
 import Select from "../../../Types/BaseDatabase/Select";
 
+/*
+ * Whether a dropdown's list request was refused because the person may not
+ * read that model (the server answers NotAuthorizedException with 422).
+ */
+export const isListRefusedForLackOfPermission: (err: unknown) => boolean = (
+  err: unknown,
+): boolean => {
+  return err instanceof HTTPErrorResponse && err.statusCode === 422;
+};
+
 export enum FormType {
   Create,
   Update,
 }
 
+/*
+ * Runs on a Create form just before the request goes out, with the model built
+ * from the form's model columns and the misc data the request will carry (the
+ * same object: what the hook adds or removes there is what is sent).
+ *
+ * `formValues` is every value the form holds, exactly as submitted - the
+ * inputs that are not model columns included. Read those values from here
+ * rather than from `miscDataProps`, which keeps only the truthy ones: a
+ * number input holding 0 or a switch left off would otherwise vanish.
+ */
+export type ModelFormOnBeforeCreate<
+  TBaseModel extends BaseModel | AnalyticsBaseModel,
+> = (
+  item: TBaseModel,
+  miscDataProps: JSONObject,
+  formValues: JSONObject,
+) => Promise<TBaseModel>;
+
 export interface ModelField<TBaseModel extends BaseModel | AnalyticsBaseModel>
   extends Field<TBaseModel> {
   overrideField?:
@@ -114,9 +143,7 @@ export interface ComponentProps<TBaseModel extends BaseModel> {
   initialValues?: FormValues<TBaseModel> | undefined;
   modelIdToEdit?: ObjectID | undefined;
   onError?: ((error: string) => void) | undefined;
-  onBeforeCreate?:
-    | ((item: TBaseModel, miscDataProps: JSONObject) => Promise<TBaseModel>)
-    | undefined;
+  onBeforeCreate?: ModelFormOnBeforeCreate<TBaseModel> | undefined;
   saveRequestOptions?: RequestOptions | undefined;
   doNotFetchExistingModel?: boolean | undefined;
   modelAPI?: typeof ModelAPI | undefined;
@@ -587,8 +614,22 @@ const ModelForm: <TBaseModel extends BaseModel>(
 
     setIsFetchingDropdownOptions(true);
 
-    try {
-      for (const field of fieldsToFetch) {
+    /*
+     * Each dropdown is fetched on its own, so one that fails still leaves the
+     * others their options. The first failure is shown once they are done,
+     * except a list the person may not read at all: that dropdown is simply
+     * left empty (and remembered as empty), as EntityDropdown does for its
+     * own requests. Reading the related model is a separate permission from
+     * editing this one, so someone may edit a field whose options they cannot
+     * list - an incident member and the status pages an incident is limited
+     * to - and a form-wide error on every step would say the form is broken
+     * when it is not. Pages that care explain the empty list next to the
+     * field.
+     */
+    let firstFetchError: unknown = null;
+
+    for (const field of fieldsToFetch) {
+      try {
         if (field.dropdownModal && field.dropdownModal.type) {
           const tempModel: BaseModel = new field.dropdownModal.type();
           const select: any = {
@@ -788,9 +829,26 @@ const ModelForm: <TBaseModel extends BaseModel>(
             selectByAccessControlProps: field.selectByAccessControlProps,
           });
         }
+      } catch (err) {
+        if (isListRefusedForLackOfPermission(err) && field.dropdownModal) {
+          field.dropdownOptions = [];
+
+          setCachedDropdownOptions(field.dropdownModal, {
+            dropdownOptions: [],
+            selectByAccessControlProps: undefined,
+          });
+
+          continue;
+        }
+
+        if (firstFetchError === null) {
+          firstFetchError = err;
+        }
       }
-    } catch (err) {
-      setError(API.getFriendlyMessage(err));
+    }
+
+    if (firstFetchError !== null) {
+      setError(API.getFriendlyMessage(firstFetchError));
     }
 
     if (generation === fieldsRunGeneration.current) {
@@ -1024,7 +1082,11 @@ const ModelForm: <TBaseModel extends BaseModel>(
       ) as TBaseModel;
 
       if (props.onBeforeCreate && props.formType === FormType.Create) {
-        tBaseModel = await props.onBeforeCreate(tBaseModel, miscDataProps);
+        tBaseModel = await props.onBeforeCreate(
+          tBaseModel,
+          miscDataProps,
+          values as JSONObject,
+        );
       }
 
       result = await modelAPI.createOrUpdate<TBaseModel>({

package/UI/Components/Forms/Validation.ts

@@ -51,7 +51,7 @@ const interpolateTemplate: (
  * we fall back to JS-interpolating the English template, so placeholders are
  * never shown literally and behavior is unchanged where i18n isn't set up.
  */
-const translateValidationMessage: (
+export const translateValidationMessage: (
   template: string,
   values?: InterpolationValues,
 ) => string = (template: string, values: InterpolationValues = {}): string => {

package/UI/Components/ModelFormModal/ModelFormModal.tsx

@@ -5,12 +5,12 @@ import ButtonType from "../Button/ButtonTypes";
 import { FormProps } from "../Forms/BasicForm";
 import ModelForm, {
   ComponentProps as ModelFormComponentProps,
+  ModelFormOnBeforeCreate,
 } from "../Forms/ModelForm";
 import FormValues from "../Forms/Types/FormValues";
 import FormAnalyticsName from "../Forms/Utils/FormAnalyticsName";
 import Modal, { ModalWidth } from "../Modal/Modal";
 import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
-import { JSONObject } from "../../../Types/JSON";
 import ObjectID from "../../../Types/ObjectID";
 import React, { MutableRefObject, ReactElement, useRef, useState } from "react";
 
@@ -28,9 +28,7 @@ export interface ComponentProps<TBaseModel extends BaseModel> {
   submitButtonStyleType?: undefined | ButtonStyleType;
   formProps: ModelFormComponentProps<TBaseModel>;
   modelIdToEdit?: ObjectID | undefined;
-  onBeforeCreate?:
-    | ((item: TBaseModel, miscDataProps: JSONObject) => Promise<TBaseModel>)
-    | undefined;
+  onBeforeCreate?: ModelFormOnBeforeCreate<TBaseModel> | undefined;
   footer?: ReactElement | undefined;
   formRef?: undefined | MutableRefObject<FormProps<FormValues<TBaseModel>>>;
 }

package/UI/Components/ModelTable/AnalyticsModelTable.tsx

@@ -13,6 +13,7 @@ import Select from "../../../Types/BaseDatabase/Select";
 import Sort from "../../../Types/BaseDatabase/Sort";
 import GroupBy from "../../../Types/BaseDatabase/GroupBy";
 import RequestOptions from "../../Utils/API/RequestOptions";
+import { ModelFormOnBeforeCreate } from "../Forms/ModelForm";
 
 export interface ComponentProps<TBaseModel extends AnalyticsBaseModel>
   extends BaseTableProps<TBaseModel> {
@@ -47,12 +48,7 @@ const AnalyticsModelTable: <TBaseModel extends AnalyticsBaseModel>(
         showCreateEditModal: (_data: {
           modalType: ModalType;
           modelIdToEdit?: ObjectID | undefined;
-          onBeforeCreate?:
-            | ((
-                item: TBaseModel,
-                miscDataProps: JSONObject,
-              ) => Promise<TBaseModel>)
-            | undefined;
+          onBeforeCreate?: ModelFormOnBeforeCreate<TBaseModel> | undefined;
           onSuccess?: ((item: TBaseModel) => void) | undefined;
           onClose?: (() => void) | undefined;
         }): ReactElement => {

package/UI/Components/ModelTable/BaseModelTable.tsx

@@ -45,7 +45,7 @@ import ErrorMessage from "../ErrorMessage/ErrorMessage";
 import ClassicFilterType from "../Filters/Types/Filter";
 import FilterData from "../Filters/Types/FilterData";
 import { FormProps, FormSummaryConfig } from "../Forms/BasicForm";
-import { ModelField } from "../Forms/ModelForm";
+import { ModelField, ModelFormOnBeforeCreate } from "../Forms/ModelForm";
 import { FormStep } from "../Forms/Types/FormStep";
 import FormValues from "../Forms/Types/FormValues";
 import List from "../List/List";
@@ -186,9 +186,7 @@ export interface BaseTableCallbacks<
   showCreateEditModal: (data: {
     modalType: ModalType;
     modelIdToEdit?: ObjectID | undefined;
-    onBeforeCreate?:
-      | ((item: TBaseModel, miscDataProps: JSONObject) => Promise<TBaseModel>)
-      | undefined;
+    onBeforeCreate?: ModelFormOnBeforeCreate<TBaseModel> | undefined;
     onSuccess?: ((item: TBaseModel) => void) | undefined;
     onClose?: (() => void) | undefined;
   }) => ReactElement;
@@ -283,9 +281,7 @@ export interface BaseTableProps<
   groupBy?: GroupBy<TBaseModel> | undefined;
   onBeforeFetch?: (() => Promise<TBaseModel>) | undefined;
   createInitialValues?: FormValues<TBaseModel> | undefined;
-  onBeforeCreate?:
-    | ((item: TBaseModel, miscDataProps: JSONObject) => Promise<TBaseModel>)
-    | undefined;
+  onBeforeCreate?: ModelFormOnBeforeCreate<TBaseModel> | undefined;
   // Runs after both create and edit; modalType identifies which form was saved.
   onCreateSuccess?:
     | ((item: TBaseModel, modalType?: ModalType) => Promise<TBaseModel>)
@@ -4764,6 +4760,7 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
           onBeforeCreate: async (
             item: TBaseModel,
             miscDataProps: JSONObject,
+            formValues: JSONObject,
           ) => {
             if (
               showAs === ShowAs.OrderedStatesList &&
@@ -4777,7 +4774,11 @@ const BaseModelTable: <TBaseModel extends BaseModel | AnalyticsBaseModel>(
             }
 
             if (props.onBeforeCreate) {
-              item = await props.onBeforeCreate(item, miscDataProps);
+              item = await props.onBeforeCreate(
+                item,
+                miscDataProps,
+                formValues,
+              );
             }
 
             return item;

package/UI/Components/ModelTable/CustomFieldColumns.tsx

@@ -7,6 +7,7 @@ import BaseModel from "../../../Models/DatabaseModels/DatabaseBaseModel/Database
 import CustomFieldType from "../../../Types/CustomField/CustomFieldType";
 import OneUptimeDate from "../../../Types/Date";
 import { CustomFieldDefinition } from "../../../Types/CustomField/CustomFieldDefinition";
+import { CUSTOM_FIELD_COLUMN_ID_PREFIX } from "../../../Types/CustomField/CustomFieldSavedViews";
 import {
   CustomFieldDropdownOption,
   parseCustomFieldDropdownOptions,
@@ -316,6 +317,14 @@ export const renderCustomFieldValue: RenderCustomFieldValueFunction = (data: {
     return <span>{JSON.stringify(value)}</span>;
   }
 
+  /*
+   * Long text keeps its line breaks, as the type promises and as the Custom
+   * Fields card and its email show it; runs of spaces still collapse.
+   */
+  if (definition.customFieldType === CustomFieldType.LongText) {
+    return <span className="whitespace-pre-line">{String(value)}</span>;
+  }
+
   return <span>{String(value)}</span>;
 };
 
@@ -343,7 +352,11 @@ export const getCustomFieldColumns: GetCustomFieldColumnsFunction = <
   return (data.definitions || []).map(
     (definition: CustomFieldDefinition): Column<TBaseModel> => {
       return {
-        id: `${CustomFieldsColumnKey}.${definition.name}`,
+        /*
+         * The prefix is shared with renaming a field, which rewrites saved
+         * views' column lists (CustomFieldSavedViews).
+         */
+        id: `${CUSTOM_FIELD_COLUMN_ID_PREFIX}${definition.name}`,
         field: {
           [CustomFieldsColumnKey]: true,
         } as Column<TBaseModel>["field"],

package/UI/Components/ModelTable/ModelTable.tsx

@@ -7,7 +7,11 @@ import PermissionGate, {
   ModelAction,
   PermissionGateResult,
 } from "../../Utils/PermissionGate";
-import { FormType, ModelField } from "../Forms/ModelForm";
+import {
+  FormType,
+  ModelField,
+  ModelFormOnBeforeCreate,
+} from "../Forms/ModelForm";
 import ModelFormModal from "../ModelFormModal/ModelFormModal";
 import BaseModelTable, {
   BaseTableProps,
@@ -260,12 +264,7 @@ const ModelTable: <TBaseModel extends BaseModel>(
           showCreateEditModal: (data: {
             modalType: ModalType;
             modelIdToEdit?: ObjectID | undefined;
-            onBeforeCreate?:
-              | ((
-                  item: TBaseModel,
-                  miscDataProps: JSONObject,
-                ) => Promise<TBaseModel>)
-              | undefined;
+            onBeforeCreate?: ModelFormOnBeforeCreate<TBaseModel> | undefined;
             onSuccess?: ((item: TBaseModel) => void) | undefined;
             onClose?: (() => void) | undefined;
           }): ReactElement => {

package/UI/Utils/SensitiveUrlToken.ts

@@ -19,12 +19,17 @@
 const STORAGE_KEY: string = "oneuptime-sensitive-url-token";
 
 /*
- * Route segments whose NEXT path segment is a single-use bearer token. Matched
- * against the second-to-last segment, so this covers
- * /accounts/reset-password/<token>, /reset-password/<token> and
- * /status-page/<id>/reset-password/<token> alike.
+ * Route segments whose NEXT path segment is a bearer token. Matched against
+ * the second-to-last segment, so this covers /accounts/reset-password/<token>,
+ * /reset-password/<token> and /status-page/<id>/reset-password/<token> alike.
+ * "unsubscribe" is a status page subscriber's unsubscribe link, whose last
+ * segment is <subscriberId>-<token> (Common/Types/StatusPage/StatusPageSubscriberUnsubscribe).
  */
-const TOKEN_ROUTES: Array<string> = ["reset-password", "verify-email"];
+const TOKEN_ROUTES: Array<string> = [
+  "reset-password",
+  "verify-email",
+  "unsubscribe",
+];
 
 interface HandoffWindow extends Window {
   __ONEUPTIME_SENSITIVE_URL_TOKEN__?: string | undefined;

package/Utils/API.ts

@@ -28,9 +28,52 @@ import Sleep from "../Types/Sleep";
 import HTTPResponseBodyReader, {
   HTTPResponseBodyBudget,
 } from "./HTTPResponseBodyReader";
+import HostAddressUtil from "./HostAddressUtil";
+import ProbeNetworkFailureUtil, {
+  ProbeNetworkFailure,
+  ProbeNetworkFailureKind,
+  ProbeNetworkOperation,
+} from "./ProbeNetworkFailureUtil";
 import type { Agent as HttpAgent } from "http";
 import type { Agent as HttpsAgent } from "https";
 
+/*
+ * A request that failed on the probe itself, before anything reached the
+ * target. See API.getProbeSideRequestFailure.
+ */
+interface ProbeSideRequestFailure {
+  failure: ProbeNetworkFailure;
+  // The request's host, bare, or a stand-in when the error does not carry it.
+  host: string;
+  isIPv6Destination: boolean;
+}
+
+// What a probe-side failure calls the target when the error has no request URL.
+const UNKNOWN_REQUEST_HOST: string = "the server";
+
+// How far down an error's `cause` / `errors` the connect addresses are read.
+const MAX_CONNECT_ADDRESS_DEPTH: number = 5;
+
+/*
+ * The code a probe-side failure is reported under. Taken from the
+ * classification rather than the thrown error because fetch's TypeError and
+ * the API monitor's APIException have no usable code of their own, and an
+ * aggregate carries only its first attempt's. NoRouteToHost never comes out
+ * of a TCP connect; it is listed so the map stays total.
+ */
+const PROBE_NETWORK_FAILURE_ERROR_CODES: Record<
+  ProbeNetworkFailureKind,
+  string
+> = {
+  [ProbeNetworkFailureKind.NoSourceAddress]: "EADDRNOTAVAIL",
+  [ProbeNetworkFailureKind.AddressFamilyNotSupported]: "EAFNOSUPPORT",
+  [ProbeNetworkFailureKind.NetworkUnreachable]: "ENETUNREACH",
+  [ProbeNetworkFailureKind.NoRouteToHost]: "EHOSTUNREACH",
+};
+
+const NETWORK_UNREACHABLE_DESCRIPTION: string =
+  "Network unreachable. There is no route to the network where the server resides. This is typically a routing or connectivity issue.";
+
 /*
  * Diagnostic summary of one settled fetch() call, retries included. Handed
  * to RequestOptions.onRequestComplete so a caller can log WHERE a request
@@ -1299,6 +1342,30 @@ export default class API {
       };
     }
 
+    /*
+     * The connect failed on the probe, before the request left it. Checked
+     * ahead of the string rules below because none of them describe it:
+     * EADDRNOTAVAIL matched nothing and fell through to "The request was sent
+     * but no response was returned", when nothing was sent at all, and a
+     * probe with no IPv6 was told there was no route to the network where the
+     * server resides. Still the TCP connection phase, since connect() is what
+     * failed. The failure cause the monitor reports alongside this already
+     * quotes the OS error (getProbeNetworkFailureDescription), so this only
+     * says what it means for the request.
+     */
+    const probeSideFailure: ProbeSideRequestFailure | null =
+      API.getProbeSideRequestFailure(error);
+
+    if (probeSideFailure) {
+      return {
+        failedPhase: RequestFailedPhase.TCPConnection,
+        errorCode:
+          PROBE_NETWORK_FAILURE_ERROR_CODES[probeSideFailure.failure.kind],
+        errorDescription: API.getProbeSideFailureDetails(probeSideFailure),
+        rawErrorMessage,
+      };
+    }
+
     // Helper to determine the phase and description based on error code/message
     const lowerMessage: string = rawErrorMessage.toLowerCase();
 
@@ -1460,8 +1527,7 @@ export default class API {
       return {
         failedPhase: RequestFailedPhase.TCPConnection,
         errorCode: errorCode || "ENETUNREACH",
-        errorDescription:
-          "Network unreachable. There is no route to the network where the server resides. This is typically a routing or connectivity issue.",
+        errorDescription: NETWORK_UNREACHABLE_DESCRIPTION,
         rawErrorMessage,
       };
     }
@@ -1512,4 +1578,183 @@ export default class API {
       rawErrorMessage,
     };
   }
+
+  /*
+   * The failure cause for a monitor request that failed on the probe itself,
+   * in the shared probe-side wording (which quotes the OS error), or null for
+   * any other failure. A probe with no usable IPv6 fails every IPv6 URL with
+   * a bare "connect EADDRNOTAVAIL ...", which reads as the customer's site
+   * being down while it may be answering perfectly well.
+   *
+   * ENETUNREACH from a TCP connect can also be a router's "no route" to the
+   * destination, so it is only reworded for an IPv6 destination, where the
+   * shared wording says "most likely". Otherwise it keeps its message.
+   *
+   * Separate from getFriendlyErrorMessage on purpose: that one is also used
+   * by the dashboard and by the server's own outbound requests, where "this
+   * probe" would be false. Only the Website and API monitors call this.
+   */
+  public static getProbeNetworkFailureDescription(
+    error: unknown,
+  ): string | null {
+    const probeSideFailure: ProbeSideRequestFailure | null =
+      API.getProbeSideRequestFailure(error);
+
+    if (
+      !probeSideFailure ||
+      (!probeSideFailure.failure.isCertain &&
+        !probeSideFailure.isIPv6Destination)
+    ) {
+      return null;
+    }
+
+    return ProbeNetworkFailureUtil.describe({
+      host: probeSideFailure.host,
+      failure: probeSideFailure.failure,
+      isIPv6Destination: probeSideFailure.isIPv6Destination,
+    });
+  }
+
+  /*
+   * Classifies a request error as a connect that failed on the probe, with
+   * the host to name and whether to word it as IPv6.
+   *
+   * IPv6 wording needs evidence. It is used when every address the probe
+   * tried to connect to was IPv6 or, when the error names no address, when
+   * the request URL's host is an IPv6 literal. A dual-stack name whose IPv4
+   * attempt failed as well is not an IPv6 problem, and neither is an IPv4
+   * proxy the probe could not reach on the way to an IPv6 target.
+   */
+  private static getProbeSideRequestFailure(
+    error: unknown,
+  ): ProbeSideRequestFailure | null {
+    // The guard refuses before any socket exists; its message is its own.
+    if (error instanceof EgressGuardException) {
+      return null;
+    }
+
+    /*
+     * The API monitor gets the AxiosError wrapped in an APIException (see
+     * getErrorResponse). The wrapper's own code is an ExceptionCode number
+     * and its message carries the errno but not the OS text, so the
+     * classifier would find nothing on it.
+     */
+    const requestError: unknown =
+      error instanceof APIException && error.error ? error.error : error;
+
+    const failure: ProbeNetworkFailure | null =
+      ProbeNetworkFailureUtil.classifyError({
+        error: requestError,
+        operation: ProbeNetworkOperation.TcpConnect,
+      });
+
+    if (!failure) {
+      return null;
+    }
+
+    const requestHost: string | null = API.getRequestHost(requestError);
+    const connectAddresses: Array<string> = [];
+    API.collectConnectAddresses(requestError, 0, connectAddresses);
+
+    const isIPv6Destination: boolean =
+      connectAddresses.length > 0
+        ? connectAddresses.every((address: string) => {
+            return HostAddressUtil.isIPv6(address);
+          })
+        : Boolean(requestHost && HostAddressUtil.isIPv6(requestHost));
+
+    return {
+      failure: failure,
+      host: requestHost || UNKNOWN_REQUEST_HOST,
+      isIPv6Destination: isIPv6Destination,
+    };
+  }
+
+  /*
+   * The "Error Details" text for a probe-side failure. ENETUNREACH that is
+   * not towards IPv6 keeps the family-neutral description it always had.
+   */
+  private static getProbeSideFailureDetails(
+    probeSideFailure: ProbeSideRequestFailure,
+  ): string {
+    const failure: ProbeNetworkFailure = probeSideFailure.failure;
+
+    if (!probeSideFailure.isIPv6Destination) {
+      return failure.isCertain
+        ? "The probe could not open the connection from its own side, so the request was never sent and the server was never contacted. The failure is on the probe, not on the server."
+        : NETWORK_UNREACHABLE_DESCRIPTION;
+    }
+
+    /*
+     * EADDRNOTAVAIL from a TCP connect is also what a probe that has run
+     * out of local ports gets, IPv6 or not, so it is not stated as missing
+     * IPv6.
+     */
+    if (failure.isCertain && failure.isCauseAmbiguous) {
+      return "The probe could not open the IPv6 connection from its own side, so the request was never sent and the server was never contacted. The failure is on the probe, not on the server.";
+    }
+
+    if (failure.isCertain) {
+      return "The probe cannot send IPv6 traffic, so the request was never sent and the server was never contacted. The failure is on the probe, not on the server.";
+    }
+
+    return "There was no IPv6 route to the server. Most likely the probe has no IPv6 route rather than the server being down.";
+  }
+
+  /*
+   * The host of the URL an axios request was sent to, without IPv6
+   * brackets, or null when the error is not an axios one or has no usable
+   * URL. It is the hop that failed, which after a redirect is not
+   * necessarily the monitor's own URL.
+   */
+  private static getRequestHost(error: unknown): string | null {
+    if (!axios.isAxiosError(error) || !error.config?.url) {
+      return null;
+    }
+
+    try {
+      const requestUrl: globalThis.URL = new globalThis.URL(
+        error.config.url,
+        error.config.baseURL || undefined,
+      );
+
+      return HostAddressUtil.stripBrackets(requestUrl.hostname) || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /*
+   * Every `address` a socket error in the chain names: the error's own, its
+   * cause's (axios and fetch keep the socket error there) and each attempt
+   * of an aggregate (Node's happy-eyeballs connect, one error per address).
+   */
+  private static collectConnectAddresses(
+    value: unknown,
+    depth: number,
+    addresses: Array<string>,
+  ): void {
+    if (
+      !value ||
+      typeof value !== "object" ||
+      depth > MAX_CONNECT_ADDRESS_DEPTH
+    ) {
+      return;
+    }
+
+    const errorLike: { address?: unknown; errors?: unknown; cause?: unknown } =
+      value as { address?: unknown; errors?: unknown; cause?: unknown };
+
+    if (typeof errorLike.address === "string" && errorLike.address) {
+      addresses.push(HostAddressUtil.stripBrackets(errorLike.address));
+    }
+
+    if (Array.isArray(errorLike.errors)) {
+      for (const attempt of errorLike.errors) {
+        API.collectConnectAddresses(attempt, depth + 1, addresses);
+      }
+    }
+
+    API.collectConnectAddresses(errorLike.cause, depth + 1, addresses);
+  }
 }