@oneuptime/common 12.0.27 → 12.0.29

package/UI/Components/LogsViewer/components/HistogramTooltip.tsx

@@ -28,26 +28,27 @@ function formatTooltipTime(label: string | undefined): string {
     return label;
   }
 
-  const now: Date = new Date();
-  const isToday: boolean = date.toDateString() === now.toDateString();
-
-  const time: string = date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-  });
-
-  if (isToday) {
-    return time;
+  const use12HourFormat: boolean = OneUptimeDate.getUserPrefers12HourFormat();
+
+  /*
+   * Today's buckets need no date on them - the explorer's own range picker
+   * already says which day is on screen. "Today" has to be decided in the
+   * configured timezone, or buckets either side of midnight there get the
+   * date added and dropped a few hours off.
+   */
+  if (
+    OneUptimeDate.areOnTheSameLocalDay(date, OneUptimeDate.getCurrentDate())
+  ) {
+    return OneUptimeDate.getLocalTimeString(date, {
+      includeSeconds: true,
+      use12HourFormat,
+    });
   }
 
-  const dateStr: string = date.toLocaleDateString([], {
-    month: "short",
-    day: "numeric",
+  return OneUptimeDate.getDateAsLocalShortDateTimeString(date, {
+    includeSeconds: true,
+    use12HourFormat,
   });
-
-  return `${dateStr}, ${time}`;
 }
 
 const HistogramTooltip: FunctionComponent<HistogramTooltipProps> = (

package/UI/Components/LogsViewer/components/LogsAnalyticsView.tsx

@@ -134,17 +134,32 @@ function pivotTimeseriesData(rows: Array<AnalyticsTimeseriesRow>): {
   };
 }
 
-function formatTickTime(time: string): string {
+export function formatTickTime(time: string): string {
   const date: Date = OneUptimeDate.fromString(time);
 
   if (isNaN(date.getTime())) {
     return time;
   }
 
-  return date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
+  return OneUptimeDate.getLocalTimeString(date, {
+    use12HourFormat: OneUptimeDate.getUserPrefers12HourFormat(),
+  });
+}
+
+/** The bucket a tooltip is pointing at, dated because it can be any day in the window. */
+export function formatTooltipLabel(label: string | undefined): string {
+  if (!label) {
+    return "";
+  }
+
+  const date: Date = OneUptimeDate.fromString(label);
+
+  if (isNaN(date.getTime())) {
+    return label;
+  }
+
+  return OneUptimeDate.getDateAsLocalShortDateTimeString(date, {
+    use12HourFormat: OneUptimeDate.getUserPrefers12HourFormat(),
   });
 }
 
@@ -234,32 +249,10 @@ const AnalyticsTooltip: FunctionComponent<AnalyticsTooltipProps> = (
     0,
   );
 
-  const formatTime: (label: string | undefined) => string = (
-    label: string | undefined,
-  ): string => {
-    if (!label) {
-      return "";
-    }
-
-    const date: Date = OneUptimeDate.fromString(label);
-
-    if (isNaN(date.getTime())) {
-      return label;
-    }
-
-    return date.toLocaleString([], {
-      month: "short",
-      day: "numeric",
-      hour: "2-digit",
-      minute: "2-digit",
-      hour12: false,
-    });
-  };
-
   return (
     <div className="rounded-lg border border-gray-200/80 bg-white/95 px-3.5 py-2.5 shadow-lg backdrop-blur-sm">
       <p className="mb-2 border-b border-gray-100 pb-2 font-mono text-[11px] font-medium text-gray-400">
-        {formatTime(props.label)}
+        {formatTooltipLabel(props.label)}
       </p>
       <div className="space-y-1">
         {entries.map((entry: { key: string; value: number; color: string }) => {

package/UI/Components/LogsViewer/components/LogsHistogram.tsx

@@ -68,10 +68,8 @@ function formatTickTime(time: string): string {
     return time;
   }
 
-  return date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
+  return OneUptimeDate.getLocalTimeString(date, {
+    use12HourFormat: OneUptimeDate.getUserPrefers12HourFormat(),
   });
 }
 

package/UI/Components/TelemetryViewer/components/TelemetryHistogram.tsx

@@ -73,10 +73,8 @@ function formatTickTime(time: string): string {
     return time;
   }
 
-  return date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false,
+  return OneUptimeDate.getLocalTimeString(date, {
+    use12HourFormat: OneUptimeDate.getUserPrefers12HourFormat(),
   });
 }
 

package/UI/Components/TelemetryViewer/components/TelemetryHistogramTooltip.tsx

@@ -34,26 +34,27 @@ function formatTooltipTime(label: string | undefined): string {
     return label;
   }
 
-  const now: Date = new Date();
-  const isToday: boolean = date.toDateString() === now.toDateString();
+  const use12HourFormat: boolean = OneUptimeDate.getUserPrefers12HourFormat();
 
-  const time: string = date.toLocaleTimeString([], {
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-    hour12: false,
-  });
-
-  if (isToday) {
-    return time;
+  /*
+   * Today's buckets need no date on them - the explorer's own range picker
+   * already says which day is on screen. "Today" has to be decided in the
+   * configured timezone, or buckets either side of midnight there get the
+   * date added and dropped a few hours off.
+   */
+  if (
+    OneUptimeDate.areOnTheSameLocalDay(date, OneUptimeDate.getCurrentDate())
+  ) {
+    return OneUptimeDate.getLocalTimeString(date, {
+      includeSeconds: true,
+      use12HourFormat,
+    });
   }
 
-  const dateStr: string = date.toLocaleDateString([], {
-    month: "short",
-    day: "numeric",
+  return OneUptimeDate.getDateAsLocalShortDateTimeString(date, {
+    includeSeconds: true,
+    use12HourFormat,
   });
-
-  return `${dateStr}, ${time}`;
 }
 
 const TelemetryHistogramTooltip: FunctionComponent<

package/UI/Utils/Navigation.ts

@@ -270,6 +270,42 @@ abstract class Navigation {
     this.navigateHook(-1);
   }
 
+  /**
+   * Return whether a value is an unambiguous same-origin path. Redirect
+   * targets must be paths rather than URLs so schemes, protocol-relative
+   * values, and backslash authority tricks can never reach a browser
+   * navigation sink.
+   */
+  public static isSafeInternalRoute(route: Route | string): boolean {
+    const routeValue: string = route.toString();
+
+    if (
+      !routeValue.startsWith("/") ||
+      routeValue.startsWith("//") ||
+      routeValue.includes("\\")
+    ) {
+      return false;
+    }
+
+    try {
+      /*
+       * URL accepts characters that Route deliberately rejects. Validate the
+       * exact sink contract here so a value marked safe cannot crash later
+       * when a caller constructs the Route used for navigation.
+       */
+      new Route(routeValue);
+
+      const parsedUrl: globalThis.URL = new window.URL(
+        routeValue,
+        window.location.origin,
+      );
+
+      return parsedUrl.origin === window.location.origin;
+    } catch {
+      return false;
+    }
+  }
+
   public static navigate(
     to: Route | URL,
     options?: {
@@ -288,6 +324,12 @@ abstract class Navigation {
     }
 
     if (options?.forceNavigate && to instanceof Route) {
+      if (!this.isSafeInternalRoute(to)) {
+        throw new BadDataException(
+          `Cannot force navigate to a non-internal route: ${finalUrl}`,
+        );
+      }
+
       window.location.href = finalUrl;
       return;
     }

package/Utils/Array.ts

@@ -1,6 +1,43 @@
 import ObjectID from "../Types/ObjectID";
 
 export default class ArrayUtil {
+  /*
+   * Run handler over every item, at most `concurrency` of them in flight.
+   *
+   * For work that is spent waiting on the network rather than on the CPU -
+   * walking a list of customer domains and making a request against each -
+   * awaiting one at a time leaves the caller idle for almost all of its wall
+   * clock, and a single slow item delays every item behind it.
+   *
+   * Items are handed out in order, so a caller that has sorted by urgency still
+   * gets the urgent ones started first. handler is expected to deal with its
+   * own failures: as with Promise.all, the first rejection is what the caller
+   * sees, and it does not stop work already in flight.
+   */
+  public static async forEachWithConcurrency<T>(
+    array: Array<T>,
+    concurrency: number,
+    handler: (item: T) => Promise<void>,
+  ): Promise<void> {
+    let nextIndex: number = 0;
+
+    const worker: () => Promise<void> = async (): Promise<void> => {
+      while (nextIndex < array.length) {
+        const index: number = nextIndex++;
+        await handler(array[index] as T);
+      }
+    };
+
+    await Promise.all(
+      Array.from(
+        { length: Math.max(1, Math.min(concurrency, array.length)) },
+        (): Promise<void> => {
+          return worker();
+        },
+      ),
+    );
+  }
+
   public static mergeStringArrays(
     array1: Array<string>,
     array2: Array<string>,

package/Utils/CertificateReissue.ts

@@ -0,0 +1,128 @@
+import OneUptimeDate from "../Types/Date";
+
+/*
+ * The cooldown that sits behind the "Reissue SSL Certificate" button on a
+ * custom domain.
+ *
+ * OneUptime orders certificates from Let's Encrypt against a single ACME
+ * account shared by every customer on the installation, so a button that any
+ * customer can press is a button that spends everybody's allowance. Two of
+ * Let's Encrypt's limits are the ones this guards:
+ *
+ *  - 5 failed validations per account, per hostname, per hour. A domain whose
+ *    CNAME is half-broken fails validation every single time, so an
+ *    unthrottled button is a way to burn that hostname's whole hourly budget
+ *    in seconds - including the budget the automated renewal cron needs.
+ *  - 5 duplicate certificates per week for the same exact set of hostnames.
+ *    A reissue is by definition a duplicate certificate: same hostname, no
+ *    change. This is the limit a determined presser reaches second.
+ *
+ * Deliberately pure and synchronous, and deliberately in Common/Utils rather
+ * than Common/Server: the dashboard renders the very same countdown the API
+ * will enforce, so the button explains itself before it is pressed instead of
+ * only after the request comes back rejected.
+ *
+ * The cooldown is keyed off when a reissue was REQUESTED, not when one
+ * succeeded. A request that fails at the CA still cost a validation attempt,
+ * and a failing domain is exactly the domain a frustrated customer presses
+ * again - so a failed attempt must start the clock just as a successful one
+ * does.
+ */
+export default class CertificateReissueUtil {
+  /*
+   * Note on the value: 24 hours permits 7 reissues a week, which is above the
+   * 5-duplicate-certificates-per-week limit described above. That is a
+   * deliberate choice, not an oversight - reaching it needs a customer to
+   * press the button on six consecutive days, and the failure that follows is
+   * a clear, temporary error from the CA rather than the sustained burst the
+   * per-hour validation limit punishes. The value is a single constant so the
+   * trade can be revisited in one place.
+   */
+  public static readonly COOLDOWN_IN_HOURS: number = 24;
+
+  /*
+   * The newest "requested at" stamp that is already out of cooldown.
+   *
+   * A row is eligible for another reissue when its stamp is null or is at or
+   * before this instant. The server turns this into the WHERE clause it
+   * claims the row with, so the comparison that decides eligibility is the
+   * same one on both sides.
+   */
+  public static getCooldownCutoff(now: Date): Date {
+    return OneUptimeDate.addRemoveHours(
+      OneUptimeDate.fromString(now),
+      -CertificateReissueUtil.COOLDOWN_IN_HOURS,
+    );
+  }
+
+  // When the domain may be reissued again, given its last request.
+  public static getNextReissueAllowedAt(lastRequestedAt: Date): Date {
+    return OneUptimeDate.addRemoveHours(
+      OneUptimeDate.fromString(lastRequestedAt),
+      CertificateReissueUtil.COOLDOWN_IN_HOURS,
+    );
+  }
+
+  /*
+   * A domain that has never been reissued is never cooling down, which is why
+   * null is accepted here rather than being the caller's problem.
+   */
+  public static isInCooldown(
+    lastRequestedAt: Date | null | undefined,
+    now: Date,
+  ): boolean {
+    if (!lastRequestedAt) {
+      return false;
+    }
+
+    return OneUptimeDate.isAfter(
+      CertificateReissueUtil.getNextReissueAllowedAt(lastRequestedAt),
+      OneUptimeDate.fromString(now),
+    );
+  }
+
+  /*
+   * How much longer the customer has to wait, in words. Whole minutes, since
+   * the countdown is only ever read by a person deciding whether to come back
+   * later.
+   */
+  public static getTimeRemainingText(lastRequestedAt: Date, now: Date): string {
+    const nextAllowedAt: Date =
+      CertificateReissueUtil.getNextReissueAllowedAt(lastRequestedAt);
+
+    const totalMinutes: number = Math.max(
+      0,
+      OneUptimeDate.getMinutesBetweenTwoDates(
+        OneUptimeDate.fromString(now),
+        nextAllowedAt,
+      ),
+    );
+
+    if (totalMinutes < 1) {
+      return "less than a minute";
+    }
+
+    const hours: number = Math.floor(totalMinutes / 60);
+    const minutes: number = totalMinutes % 60;
+
+    const parts: Array<string> = [];
+
+    if (hours > 0) {
+      parts.push(`${hours} ${hours === 1 ? "hour" : "hours"}`);
+    }
+
+    if (minutes > 0) {
+      parts.push(`${minutes} ${minutes === 1 ? "minute" : "minutes"}`);
+    }
+
+    return parts.join(" ");
+  }
+
+  /*
+   * The one sentence the API returns and the dashboard shows. Kept here so a
+   * customer reads the same explanation wherever they hit the limit.
+   */
+  public static getCooldownMessage(lastRequestedAt: Date, now: Date): string {
+    return `A certificate reissue was already requested for this domain in the last ${CertificateReissueUtil.COOLDOWN_IN_HOURS} hours. Certificates are issued by Let's Encrypt, which rate limits how often the same domain can be issued, so a reissue can only be requested once every ${CertificateReissueUtil.COOLDOWN_IN_HOURS} hours. Please try again in ${CertificateReissueUtil.getTimeRemainingText(lastRequestedAt, now)}.`;
+  }
+}