@oneuptime/common 11.7.2 → 11.7.4

package/UI/Utils/TableFilterUrlState.ts

@@ -121,6 +121,59 @@ export default class TableFilterUrlState {
     });
   }
 
+  /**
+   * Serialize one slice exactly the way {@link write} puts it on the URL.
+   * Returns null for an empty slice (`null`, or an object with no keys) and for
+   * anything that will not serialize, so callers can treat "nothing to write"
+   * and "could not write" the same way.
+   */
+  public static serializeState(
+    state: JSONObject | null | undefined,
+  ): string | null {
+    if (!state || Object.keys(state).length === 0) {
+      return null;
+    }
+
+    try {
+      return JSON.stringify(JSONFunctions.serialize(state));
+    } catch (err) {
+      Logger.warn(`TableFilterUrlState: could not serialize state: ${err}`);
+      return null;
+    }
+  }
+
+  /**
+   * Query params that land a table already in a given filter/facet/view state,
+   * for *linking* to it from elsewhere in the product — a count on one page
+   * whose rows only exist on another.
+   *
+   * Values are percent-encoded here because {@link Route.addQueryParams}
+   * concatenates them into the route verbatim, while {@link read} pulls them
+   * back out through `URLSearchParams`, which decodes. Serialized facet state
+   * is JSON, so leaving it raw would produce a URL the reader cannot parse.
+   *
+   * Empty slices are omitted rather than written as an empty param — the
+   * absence of the param is what "no state" already means to {@link read}.
+   */
+  public static getLinkQueryParams(
+    tableId: string,
+    states: Partial<Record<TableFilterUrlStateKind, JSONObject | null>>,
+  ): Dictionary<string> {
+    const params: Dictionary<string> = {};
+
+    for (const kind of Object.keys(states) as Array<TableFilterUrlStateKind>) {
+      const value: string | null = this.serializeState(states[kind]);
+
+      if (value === null) {
+        continue;
+      }
+
+      params[this.getParamName(tableId, kind)] = encodeURIComponent(value);
+    }
+
+    return params;
+  }
+
   /*
    * Read a previously-persisted snapshot from the URL. Returns null when absent,
    * empty, or unparseable (e.g. a hand-edited param) so callers fall back to
@@ -195,26 +248,12 @@ export default class TableFilterUrlState {
       const state: JSONObject | null | undefined = states[kind];
       const paramName: string = this.getParamName(tableId, kind);
 
-      let value: string | null = null;
-
-      try {
-        const hasState: boolean = Boolean(
-          state && Object.keys(state).length > 0,
-        );
-
-        value = hasState
-          ? JSON.stringify(JSONFunctions.serialize(state as JSONObject))
-          : null;
-      } catch (err) {
-        /*
-         * Serialization failure (shouldn't happen for filter data) — drop the
-         * param rather than break the table, and leave a breadcrumb.
-         */
-        Logger.warn(
-          `TableFilterUrlState: could not serialize "${paramName}": ${err}`,
-        );
-        value = null;
-      }
+      /*
+       * A serialization failure (shouldn't happen for filter data) drops the
+       * param rather than breaking the table; serializeState leaves the
+       * breadcrumb.
+       */
+      let value: string | null = this.serializeState(state);
 
       if (value === null) {
         projected.delete(paramName);

package/Utils/API.ts

@@ -24,6 +24,30 @@ import Sleep from "../Types/Sleep";
 import type { Agent as HttpAgent } from "http";
 import type { Agent as HttpsAgent } from "https";
 
+/*
+ * Diagnostic summary of one settled fetch() call, retries included. Handed
+ * to RequestOptions.onRequestComplete so a caller can log WHERE a request
+ * went wrong without having to wrap every one of its call sites.
+ */
+export interface RequestOutcome {
+  method: HTTPMethod;
+  url: string;
+  elapsedInMs: number;
+  attempts: number;
+  timeoutInMs?: number | undefined;
+  // Set whenever the server answered at all — including 4xx/5xx.
+  statusCode?: number | undefined;
+  // Set when the request failed without a usable response.
+  error?: Error | undefined;
+  /*
+   * The raw axios error, when there was one. It carries the ClientRequest
+   * and its socket, which is what tells "we never got a socket" apart from
+   * "we connected and the server never replied" — the difference between a
+   * client-side and a server-side timeout.
+   */
+  axiosError?: AxiosError | undefined;
+}
+
 export interface RequestOptions {
   retries?: number | undefined;
   exponentialBackoff?: boolean | undefined;
@@ -35,6 +59,12 @@ export interface RequestOptions {
   skipAuthRefresh?: boolean | undefined;
   hasAttemptedAuthRefresh?: boolean | undefined;
   onUploadProgress?: ((event: AxiosProgressEvent) => void) | undefined;
+  /*
+   * Purely diagnostic observer, called once after the request settles. It
+   * cannot change the result and anything it throws is swallowed, so a
+   * broken logger can never break a request.
+   */
+  onRequestComplete?: ((outcome: RequestOutcome) => void) | undefined;
 }
 
 export interface APIRequestOptions {
@@ -366,6 +396,9 @@ export default class API {
       url.addQueryParams(params);
     }
 
+    const requestStartedAtInMs: number = Date.now();
+    let attempts: number = 0;
+
     try {
       const finalHeaders: Dictionary<string> = {
         ...apiHeaders,
@@ -392,6 +425,7 @@ export default class API {
 
       while (currentRetry <= maxRetries) {
         currentRetry++;
+        attempts++;
         try {
           const axiosOptions: AxiosRequestConfig = {
             method: method,
@@ -451,15 +485,63 @@ export default class API {
         result.headers as Dictionary<string>,
       );
 
+      this.notifyRequestComplete(options, {
+        method: method,
+        url: url.toString(),
+        elapsedInMs: Date.now() - requestStartedAtInMs,
+        attempts: attempts,
+        ...(options?.timeout === undefined
+          ? {}
+          : { timeoutInMs: options.timeout }),
+        statusCode: result.status,
+      });
+
       return response;
     } catch (e) {
       const error: Error | AxiosError = e as Error | AxiosError;
 
+      const elapsedInMs: number = Date.now() - requestStartedAtInMs;
+
+      const baseOutcome: RequestOutcome = {
+        method: method,
+        url: url.toString(),
+        elapsedInMs: elapsedInMs,
+        attempts: attempts,
+        ...(options?.timeout === undefined
+          ? {}
+          : { timeoutInMs: options.timeout }),
+      };
+
       if (!axios.isAxiosError(error)) {
-        throw new APIException(error.message);
+        const apiException: APIException = new APIException(error.message);
+
+        this.notifyRequestComplete(options, {
+          ...baseOutcome,
+          error: apiException,
+        });
+
+        throw apiException;
       }
 
-      const errorResponse: HTTPErrorResponse = this.getErrorResponse(error);
+      let errorResponse: HTTPErrorResponse;
+
+      /*
+       * getErrorResponse THROWS for a request that never produced a
+       * response (timeout, DNS failure, connection refused) — which is
+       * precisely the case worth reporting, so it has to be observed here
+       * rather than on the return path below.
+       */
+      try {
+        errorResponse = this.getErrorResponse(error);
+      } catch (thrownError) {
+        this.notifyRequestComplete(options, {
+          ...baseOutcome,
+          error: thrownError as Error,
+          axiosError: error,
+        });
+
+        throw thrownError;
+      }
 
       if (
         error.response?.status === 401 &&
@@ -512,10 +594,32 @@ export default class API {
       }
 
       this.handleError(errorResponse);
+
+      this.notifyRequestComplete(options, {
+        ...baseOutcome,
+        statusCode: errorResponse.statusCode,
+        axiosError: error,
+      });
+
       return errorResponse;
     }
   }
 
+  private static notifyRequestComplete(
+    options: RequestOptions | undefined,
+    outcome: RequestOutcome,
+  ): void {
+    if (!options?.onRequestComplete) {
+      return;
+    }
+
+    try {
+      options.onRequestComplete(outcome);
+    } catch {
+      // Diagnostics must never change the fate of the request they describe.
+    }
+  }
+
   private static getErrorResponse(error: AxiosError): HTTPErrorResponse {
     if (error.response) {
       return new HTTPErrorResponse(

package/Utils/Monitor/MonitorSummaryProbeUtil.ts

@@ -0,0 +1,130 @@
+/*
+ * The rules behind the "Monitor Summary" probe picker.
+ *
+ * That card used to be fed every probe in the project plus every global probe,
+ * not the probes attached to the monitor being viewed. Choosing one of the
+ * strangers answered "No summary available for the selected probe. Should be
+ * few minutes for summary to show up." about data that could never arrive -
+ * and because the list is project-probes-first, the card frequently *opened*
+ * on one. Users read that as "I changed the probe and it was not applied".
+ *
+ * The picker is a view filter over data that already exists. It cannot change
+ * which probe monitors a resource (that is a MonitorProbe row, edited under
+ * Monitor > Probes), so it must never offer a probe that does not.
+ */
+
+export interface AttachedProbe {
+  id: string;
+  name: string;
+  isEnabled: boolean;
+}
+
+export enum MonitorSummaryProbeState {
+  // Nothing is monitoring this resource at all.
+  NoProbesAttached = "NoProbesAttached",
+  // The selected probe is attached but switched off, so it will never report.
+  SelectedProbeDisabled = "SelectedProbeDisabled",
+  // Attached and enabled, but it has not reported yet. Waiting is the answer.
+  AwaitingFirstResult = "AwaitingFirstResult",
+  // There is something to render.
+  HasResults = "HasResults",
+}
+
+export default class MonitorSummaryProbeUtil {
+  /*
+   * Which probe the card should show. Keeps the user's choice as long as that
+   * probe is still attached: this runs whenever the probe list is handed down
+   * again, and unconditionally resetting to the first entry is indistinguishable
+   * from a selection that refuses to stick.
+   *
+   * With no usable previous choice it prefers an enabled probe, because a
+   * disabled one has nothing to show and opening there reads as broken.
+   */
+  public static resolveSelectedProbeId(data: {
+    probes: Array<AttachedProbe>;
+    currentlySelectedProbeId?: string | null | undefined;
+  }): string | null {
+    const probes: Array<AttachedProbe> = (data.probes || []).filter(
+      (probe: AttachedProbe) => {
+        return Boolean(probe && probe.id);
+      },
+    );
+
+    if (probes.length === 0) {
+      return null;
+    }
+
+    if (data.currentlySelectedProbeId) {
+      const stillAttached: AttachedProbe | undefined = probes.find(
+        (probe: AttachedProbe) => {
+          return probe.id === data.currentlySelectedProbeId;
+        },
+      );
+
+      if (stillAttached) {
+        return stillAttached.id;
+      }
+    }
+
+    const firstEnabledProbe: AttachedProbe | undefined = probes.find(
+      (probe: AttachedProbe) => {
+        return probe.isEnabled;
+      },
+    );
+
+    return (firstEnabledProbe || (probes[0] as AttachedProbe)).id;
+  }
+
+  /*
+   * The option labels. A disabled probe stays on the list - the user may well
+   * want to look at what it collected before it was switched off - but saying
+   * so is what stops "no summary" from looking like a bug.
+   */
+  public static getProbeDropdownOptions(data: {
+    probes: Array<AttachedProbe>;
+  }): Array<{ label: string; value: string }> {
+    return (data.probes || [])
+      .filter((probe: AttachedProbe) => {
+        return Boolean(probe && probe.id);
+      })
+      .map((probe: AttachedProbe) => {
+        const name: string = probe.name || "Unknown";
+
+        return {
+          label: probe.isEnabled ? name : `${name} (disabled)`,
+          value: probe.id,
+        };
+      });
+  }
+
+  /*
+   * Why the card has nothing to render. "No data yet", "this probe is off" and
+   * "nothing is watching this monitor" are three different situations, and
+   * telling the user to wait a few minutes for the last two is exactly how a
+   * probe change comes to look like it never applied.
+   */
+  public static getProbeState(data: {
+    isProbeableMonitor: boolean;
+    attachedProbeCount: number;
+    isSelectedProbeEnabled: boolean;
+    probeResponseCount: number;
+  }): MonitorSummaryProbeState {
+    if (data.probeResponseCount > 0) {
+      return MonitorSummaryProbeState.HasResults;
+    }
+
+    /*
+     * Non-probeable monitors (server, incoming request, telemetry...) have no
+     * probes by design, so their empty state is not a probe problem.
+     */
+    if (data.isProbeableMonitor && data.attachedProbeCount === 0) {
+      return MonitorSummaryProbeState.NoProbesAttached;
+    }
+
+    if (!data.isSelectedProbeEnabled) {
+      return MonitorSummaryProbeState.SelectedProbeDisabled;
+    }
+
+    return MonitorSummaryProbeState.AwaitingFirstResult;
+  }
+}