npm - @oneuptime/common - Versions diffs - 12.0.32 → 12.0.33 - Mend

@oneuptime/common 12.0.32 → 12.0.33

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (597) hide show

package/UI/Utils/SensitiveUrlToken.ts ADDED Viewed

@@ -0,0 +1,112 @@
+/*
+ * Client half of the sensitive-URL-token handoff.
+ *
+ * Common/Server/Views/Partials/SensitiveUrlToken.ejs runs in <head>, moves the
+ * bearer token out of the path into sessionStorage and rewrites the address bar
+ * to the token-free route. By the time React mounts, the token is no longer a
+ * route parameter, so pages read it from here instead of from the router.
+ *
+ * Deliberately not routed through Common/UI/Utils/Navigation: this is read
+ * during the reset and verification flows, where the value has to be available
+ * whether or not the bootstrap managed to clean the URL, and Navigation only
+ * ever sees whatever the router was given.
+ *
+ * TOKEN_ROUTES is duplicated in the partial. The two lists have to agree about
+ * which routes carry a token; Common/Tests/App/SensitiveUrlTokenBootstrap.test.ts
+ * asserts that they do.
+ */
+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.
+ */
+const TOKEN_ROUTES: Array<string> = ["reset-password", "verify-email"];
+interface HandoffWindow extends Window {
+  __ONEUPTIME_SENSITIVE_URL_TOKEN__?: string | undefined;
+}
+export default class SensitiveUrlToken {
+  /*
+   * The token for the current page, or "" when there is none.
+   *
+   * Order matters. sessionStorage is where the bootstrap normally puts it and
+   * is the only source that survives a reload of the cleaned URL. The in-memory
+   * handoff covers blocked storage. The path is the last resort: it only holds
+   * a token when the bootstrap could not run, and reading it keeps the flow
+   * working on the browsers where that happens.
+   */
+  public static read(): string {
+    try {
+      const stored: string | null = window.sessionStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        return stored;
+      }
+    } catch {
+      /* Private mode or storage disabled; fall through. */
+    }
+    const handedOff: string | undefined = (window as HandoffWindow)
+      .__ONEUPTIME_SENSITIVE_URL_TOKEN__;
+    if (handedOff) {
+      return handedOff;
+    }
+    return SensitiveUrlToken.readFromPath(window.location.pathname);
+  }
+  /*
+   * Pull the token out of a path, if that path is a token-bearing route.
+   * Returns "" for the cleaned form of the same route, which is what the
+   * address bar holds once the bootstrap has run.
+   */
+  public static readFromPath(pathname: string): string {
+    const segments: Array<string> = SensitiveUrlToken.segmentsOf(pathname);
+    if (segments.length < 2) {
+      return "";
+    }
+    if (!TOKEN_ROUTES.includes(segments[segments.length - 2]!)) {
+      return "";
+    }
+    const token: string = segments[segments.length - 1]!;
+    try {
+      return decodeURIComponent(token);
+    } catch {
+      // A malformed escape sequence is handed on verbatim.
+      return token;
+    }
+  }
+  /*
+   * Drop the stashed token once the flow that needed it has completed.
+   *
+   * Only call this on success. A failed reset (an expired token, a password the
+   * server rejected) has to leave the stash intact, or the retry — and any
+   * reload of the now token-free URL — has nothing to submit.
+   */
+  public static clear(): void {
+    try {
+      window.sessionStorage.removeItem(STORAGE_KEY);
+    } catch {
+      /* Nothing was stored, so nothing to remove. */
+    }
+    delete (window as HandoffWindow).__ONEUPTIME_SENSITIVE_URL_TOKEN__;
+  }
+  private static segmentsOf(pathname: string): Array<string> {
+    return (pathname || "").split("/").filter((segment: string): boolean => {
+      return segment !== "";
+    });
+  }
+}

package/UI/Utils/TestLLMProvider.ts CHANGED Viewed

@@ -9,6 +9,14 @@ import API from "./API/API";
 export interface LLMProviderTestResult {
   success: boolean;
   message: string;
+  /*
+   * Whether the provider actually used the tool offered by the connection
+   * test. Reachability alone is not enough for Ask AI or investigations —
+   * they read the user's data exclusively through tools — so a provider can
+   * connect successfully and still be unusable for every AI feature.
+   * Undefined for an older server that does not report it.
+   */
+  supportsToolCalling?: boolean | undefined;
 }
 export default class TestLLMProvider {
@@ -48,6 +56,9 @@ export default class TestLLMProvider {
         message:
           (responseData["message"] as string) ||
           "Connection successful. The LLM provider responded to a test prompt.",
+        ...(typeof responseData["supportsToolCalling"] === "boolean"
+          ? { supportsToolCalling: responseData["supportsToolCalling"] }
+          : {}),
       };
     } catch (err) {
       return {

package/Utils/EnterpriseLicense/EnterpriseLicenseSeats.ts CHANGED Viewed

@@ -222,6 +222,22 @@ export default class EnterpriseLicenseSeatsUtil {
       return null;
     }
+    /*
+     * The active-only aggregate contains none of this installation's stale
+     * reported users. Subtracting that old count would remove users belonging
+     * to active instances and under-enforce the license. Treat the complete
+     * aggregate as other-instance usage. We also cannot add the two counts:
+     * the same users may exist on both this installation and active ones.
+     * Return null to use the existing uncertainty fallback, which takes the
+     * larger complete-or-live total without subtracting or double-counting.
+     *
+     * Undefined retains the legacy behavior for responses from older license
+     * servers that did not send activity provenance.
+     */
+    if (thisInstance.isCountedTowardsUsage === false) {
+      return null;
+    }
     const ownReportedCount: number | null = this.parseCount(
       thisInstance.userCount,
     );

package/Utils/EnterpriseLicense/EnterpriseLicenseUsage.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import OneUptimeDate from "../../Types/Date";
+import EnterpriseLicenseUserCountSource from "../../Types/EnterpriseLicense/EnterpriseLicenseUserCountSource";
 /*
  * Usage reported by one self-hosted instance of an enterprise license.
@@ -7,11 +7,37 @@ import OneUptimeDate from "../../Types/Date";
  * on staging, production and gov-cloud consumes a single seat.
  */
 export interface EnterpriseLicenseInstanceUsage {
+  /*
+   * Registration is the initial communication until the instance sends its
+   * first usage report.
+   */
+  createdAt?: Date | undefined;
   userCount?: number | undefined;
   userEmailHashes?: Array<string> | undefined;
   lastReportedAt?: Date | undefined;
 }
+export interface EffectiveEnterpriseLicenseUserCountOptions {
+  instances: Array<EnterpriseLicenseInstanceUsage>;
+  storedUserCount?: number | null | undefined;
+  storedUserCountUpdatedAt?: Date | undefined;
+  storedUserCountSource?: EnterpriseLicenseUserCountSource | undefined;
+  legacyUserCount?: number | null | undefined;
+  legacyUserCountUpdatedAt?: Date | undefined;
+  /*
+   * Callers that just replaced/deleted modern rows know the stored aggregate
+   * came from those rows. They can suppress the one-time compatibility path
+   * for license records created before dedicated legacy fields existed.
+   */
+  allowStoredUserCountAsLegacyFallback?: boolean | undefined;
+  now: Date;
+}
+export interface EffectiveEnterpriseLicenseUserCount {
+  userCount: number | null;
+  source: EnterpriseLicenseUserCountSource | null;
+}
 export default class EnterpriseLicenseUsageUtil {
   /*
    * How many days before a license expires that expiry reminder emails
@@ -41,11 +67,11 @@ export default class EnterpriseLicenseUsageUtil {
     )}`;
   }
   /*
-   * Instances that stopped reporting (for example a decommissioned staging
-   * environment) stop counting towards the seat total after this many days,
-   * but are still listed so the customer can see them.
+   * An instance is inactive once it has gone this many complete days without
+   * communicating with oneuptime.com. Inactive instances stay visible, but
+   * their users no longer consume seats.
    */
-  public static readonly InstanceUsageFreshnessInDays: number = 30;
+  public static readonly InstanceUsageFreshnessInDays: number = 7;
   // SHA-256 hex digest.
   private static readonly emailHashRegex: RegExp = /^[a-f0-9]{64}$/;
@@ -136,17 +162,171 @@ export default class EnterpriseLicenseUsageUtil {
     instance: EnterpriseLicenseInstanceUsage,
     now: Date,
   ): boolean {
-    if (!instance.lastReportedAt) {
-      // Registered (license key validated) but never reported usage yet.
+    const lastCommunicatedAt: Date | undefined =
+      this.getInstanceLastCommunicatedAt(instance);
+    if (!lastCommunicatedAt) {
       return false;
     }
-    const staleBefore: Date = OneUptimeDate.addRemoveDays(
-      now,
-      -this.InstanceUsageFreshnessInDays,
+    const inactiveAfterInMilliseconds: number =
+      this.InstanceUsageFreshnessInDays * 24 * 60 * 60 * 1000;
+    const staleBefore: number = now.getTime() - inactiveAfterInMilliseconds;
+    /*
+     * Strictly greater than: at the exact seven-day boundary the instance has
+     * gone a full week without communicating and must already be inactive.
+     * Elapsed milliseconds are intentional; a daylight-saving transition
+     * must not shorten or extend the week.
+     */
+    return lastCommunicatedAt.getTime() > staleBefore;
+  }
+  public static getInstanceLastCommunicatedAt(
+    instance: EnterpriseLicenseInstanceUsage,
+  ): Date | undefined {
+    return instance.lastReportedAt || instance.createdAt;
+  }
+  /* A registration is active, but only a real report is modern seat data. */
+  public static hasActiveReportedInstanceUsage(
+    instances: Array<EnterpriseLicenseInstanceUsage>,
+    now: Date,
+  ): boolean {
+    return instances.some(
+      (instance: EnterpriseLicenseInstanceUsage): boolean => {
+        return (
+          Boolean(instance.lastReportedAt) &&
+          this.isInstanceCountedTowardsUsage(instance, now)
+        );
+      },
     );
+  }
+  public static isTimestampWithinUsageWindow(
+    timestamp: Date | undefined,
+    now: Date,
+  ): boolean {
+    return timestamp
+      ? this.isInstanceCountedTowardsUsage({ lastReportedAt: timestamp }, now)
+      : false;
+  }
+  public static hasReportedInstanceUsage(
+    instances: Array<EnterpriseLicenseInstanceUsage>,
+  ): boolean {
+    return instances.some(
+      (instance: EnterpriseLicenseInstanceUsage): boolean => {
+        return Boolean(instance.lastReportedAt);
+      },
+    );
+  }
+  /*
+   * Choose between modern per-instance reports and a separately persisted
+   * legacy license-wide heartbeat. The stored count fallback exists only for
+   * records written before those dedicated legacy columns were introduced;
+   * seeing any historical modern report proves that aggregate is not legacy.
+   * Once every authoritative communication timestamp is a week old, usage is
+   * zero.
+   */
+  public static getEffectiveUserCount(
+    options: EffectiveEnterpriseLicenseUserCountOptions,
+  ): number | null {
+    return this.getEffectiveUserCountAndSource(options).userCount;
+  }
+  public static getEffectiveUserCountAndSource(
+    options: EffectiveEnterpriseLicenseUserCountOptions,
+  ): EffectiveEnterpriseLicenseUserCount {
+    if (this.hasActiveReportedInstanceUsage(options.instances, options.now)) {
+      return {
+        userCount: this.getUniqueUserCount(options.instances, options.now),
+        source: EnterpriseLicenseUserCountSource.Instance,
+      };
+    }
+    if (
+      this.isTimestampWithinUsageWindow(
+        options.legacyUserCountUpdatedAt,
+        options.now,
+      )
+    ) {
+      return {
+        userCount: options.legacyUserCount ?? null,
+        source: EnterpriseLicenseUserCountSource.Legacy,
+      };
+    }
+    const hasRecentRegistration: boolean = options.instances.some(
+      (instance: EnterpriseLicenseInstanceUsage): boolean => {
+        return (
+          !instance.lastReportedAt &&
+          this.isInstanceCountedTowardsUsage(instance, options.now)
+        );
+      },
+    );
+    const hasRecentLegacyReport: boolean = options.storedUserCountUpdatedAt
+      ? this.isTimestampWithinUsageWindow(
+          options.storedUserCountUpdatedAt,
+          options.now,
+        )
+      : false;
+    const isExplicitLegacyFallback: boolean =
+      options.storedUserCountSource ===
+        EnterpriseLicenseUserCountSource.Legacy &&
+      !options.legacyUserCountUpdatedAt &&
+      hasRecentLegacyReport;
+    const canUseCompatibilityFallback: boolean =
+      options.allowStoredUserCountAsLegacyFallback !== false &&
+      options.storedUserCountSource !==
+        EnterpriseLicenseUserCountSource.Instance &&
+      !options.legacyUserCountUpdatedAt &&
+      !this.hasReportedInstanceUsage(options.instances);
+    if (
+      isExplicitLegacyFallback ||
+      (canUseCompatibilityFallback &&
+        (hasRecentRegistration || hasRecentLegacyReport))
+    ) {
+      return {
+        userCount: options.storedUserCount ?? null,
+        source: EnterpriseLicenseUserCountSource.Legacy,
+      };
+    }
+    if (
+      options.instances.length === 0 &&
+      (options.storedUserCount === undefined ||
+        options.storedUserCount === null) &&
+      !options.storedUserCountUpdatedAt &&
+      (options.legacyUserCount === undefined ||
+        options.legacyUserCount === null) &&
+      !options.legacyUserCountUpdatedAt &&
+      !options.storedUserCountSource
+    ) {
+      return {
+        userCount: null,
+        source: null,
+      };
+    }
+    let inactiveUsageSource: EnterpriseLicenseUserCountSource | null =
+      options.storedUserCountSource || null;
+    if (
+      !inactiveUsageSource &&
+      this.hasReportedInstanceUsage(options.instances)
+    ) {
+      inactiveUsageSource = EnterpriseLicenseUserCountSource.Instance;
+    } else if (!inactiveUsageSource && options.legacyUserCountUpdatedAt) {
+      inactiveUsageSource = EnterpriseLicenseUserCountSource.Legacy;
+    }
-    return instance.lastReportedAt.getTime() >= staleBefore.getTime();
+    return {
+      userCount: 0,
+      source: inactiveUsageSource,
+    };
   }
   /*

package/Utils/Monitor/MonitorMetricType.ts CHANGED Viewed

@@ -1,5 +1,16 @@
 import AggregationType from "../../Types/BaseDatabase/AggregationType";
-import { CheckOn } from "../../Types/Monitor/CriteriaFilter";
+import { CheckOn, CriteriaFilter } from "../../Types/Monitor/CriteriaFilter";
+import {
+  DatabaseMetricCategory,
+  DatabaseMetricDefinition,
+  getAllDatabaseMetrics,
+  getDatabaseMetricByMetricType,
+  getDatabaseMetricCategoryDescription,
+  getDatabaseMetricCategoryOrder,
+  getDatabaseMetricsByCategory,
+  getDatabaseMetricsForEngine,
+} from "../../Types/Monitor/DatabaseMetricCatalog";
+import SqlDatabaseType from "../../Types/Monitor/SqlDatabaseType";
 import MonitorMetricType from "../../Types/Monitor/MonitorMetricType";
 import MonitorType, {
   MonitorTypeHelper,
@@ -20,6 +31,19 @@ class MonitorMetricTypeUtil {
   public static getAggregationTypeByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
   ): AggregationType {
+    /*
+     * Database Health series carry their own aggregation in the catalog, so
+     * they resolve here instead of adding ~40 cases to this switch (and to
+     * the four other switches in this file). The catalog is the one place a
+     * new database metric has to be declared.
+     */
+    const databaseMetric: DatabaseMetricDefinition | null =
+      getDatabaseMetricByMetricType(monitorMetricType);
+    if (databaseMetric) {
+      return databaseMetric.defaultAggregation;
+    }
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return AggregationType.Avg;
@@ -275,6 +299,22 @@ class MonitorMetricTypeUtil {
       ];
     }
+    if (monitorType === MonitorType.Database) {
+      /*
+       * Availability first, then every catalog series in category order.
+       * Engine filtering happens in getDatabaseMetricCategories, which is
+       * the only caller that knows which engine the monitor points at - this
+       * list is the full capability set for the monitor type.
+       */
+      return [
+        MonitorMetricType.IsOnline,
+        MonitorMetricType.ResponseTime,
+        ...getAllDatabaseMetrics().map((metric: DatabaseMetricDefinition) => {
+          return metric.metricType;
+        }),
+      ];
+    }
     if (
       monitorType === MonitorType.DNS ||
       monitorType === MonitorType.DNSSEC ||
@@ -308,6 +348,14 @@ class MonitorMetricTypeUtil {
    */
   public static getMonitorMetricCategoriesByMonitorType(
     monitorType: MonitorType,
+    /*
+     * Database Health only. When the caller knows which engine the monitor
+     * is pointed at, pass it and the cards drop the series that engine can
+     * never write - so a MySQL monitor does not show a permanently empty
+     * "Transaction ID Used" chart. Omitting it shows the full capability
+     * set, which is the right fallback when the engine is not loaded yet.
+     */
+    databaseType?: SqlDatabaseType | undefined,
   ): Array<MonitorMetricCategory> {
     if (monitorType === MonitorType.Server) {
       return [
@@ -375,6 +423,10 @@ class MonitorMetricTypeUtil {
       ];
     }
+    if (monitorType === MonitorType.Database) {
+      return this.getDatabaseMetricCategories(databaseType);
+    }
     if (monitorType === MonitorType.NetworkDevice) {
       return [
         {
@@ -423,6 +475,13 @@ class MonitorMetricTypeUtil {
       return "Total Connection Time (DNS + TCP)";
     }
+    const databaseMetric: DatabaseMetricDefinition | null =
+      getDatabaseMetricByMetricType(monitorMetricType);
+    if (databaseMetric) {
+      return databaseMetric.friendlyName;
+    }
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return "Response Time";
@@ -534,6 +593,13 @@ class MonitorMetricTypeUtil {
   public static getLegendUnitByMonitorMetricType(
     monitorMetricType: MonitorMetricType,
   ): string {
+    const databaseMetric: DatabaseMetricDefinition | null =
+      getDatabaseMetricByMetricType(monitorMetricType);
+    if (databaseMetric) {
+      return databaseMetric.unit;
+    }
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return "ms";
@@ -619,6 +685,13 @@ class MonitorMetricTypeUtil {
       return "Total time spent resolving the hostname (when needed) and establishing the TCP connection.";
     }
+    const databaseMetric: DatabaseMetricDefinition | null =
+      getDatabaseMetricByMetricType(monitorMetricType);
+    if (databaseMetric) {
+      return databaseMetric.description;
+    }
     switch (monitorMetricType) {
       case MonitorMetricType.ResponseTime:
         return "Response time is the time taken for a server to respond to a request. It is the sum of the time spent waiting to establish the connection, the time spent waiting for the request to be processed, and the time spent waiting for the response to be sent.";
@@ -714,6 +787,85 @@ class MonitorMetricTypeUtil {
         return "";
     }
   }
+  /**
+   * One card per catalog category, in the order an operator walks them
+   * during an incident. When `databaseType` is given, a category whose
+   * metrics are all unsupported on that engine is dropped entirely rather
+   * than rendered as a card of empty charts.
+   */
+  public static getDatabaseMetricCategories(
+    databaseType?: SqlDatabaseType | undefined,
+  ): Array<MonitorMetricCategory> {
+    const supported: Array<MonitorMetricType> | null = databaseType
+      ? getDatabaseMetricsForEngine(databaseType).map(
+          (metric: DatabaseMetricDefinition) => {
+            return metric.metricType;
+          },
+        )
+      : null;
+    const categories: Array<MonitorMetricCategory> = [];
+    for (const category of getDatabaseMetricCategoryOrder()) {
+      const metrics: Array<MonitorMetricType> = getDatabaseMetricsByCategory(
+        category,
+      )
+        .filter((metric: DatabaseMetricDefinition) => {
+          return !supported || supported.includes(metric.metricType);
+        })
+        .map((metric: DatabaseMetricDefinition) => {
+          return metric.metricType;
+        });
+      /*
+       * Availability additionally carries the shared probe series, so it is
+       * never empty even if every catalog metric in it were filtered out.
+       */
+      if (category === DatabaseMetricCategory.Availability) {
+        metrics.unshift(
+          MonitorMetricType.IsOnline,
+          MonitorMetricType.ResponseTime,
+        );
+      }
+      if (metrics.length === 0) {
+        continue;
+      }
+      categories.push({
+        title: category,
+        description: getDatabaseMetricCategoryDescription(category),
+        metrics: metrics,
+      });
+    }
+    return categories;
+  }
+  /**
+   * The metric series a criteria filter reads.
+   *
+   * Database Health filters name their series in
+   * databaseMonitorOptions.metricType rather than in the CheckOn itself, so
+   * resolving from the CheckOn alone would return null and silently turn
+   * "evaluate over time" into an instantaneous comparison. Callers that hold
+   * the whole filter - EvaluateOverTime does - must use this instead of
+   * getMonitorMetricTypeByCheckOnOrNull.
+   */
+  public static getMonitorMetricTypeByCriteriaFilterOrNull(
+    criteriaFilter: CriteriaFilter,
+  ): MonitorMetricType | null {
+    if (criteriaFilter.checkOn === CheckOn.DatabaseMetric) {
+      return criteriaFilter.databaseMonitorOptions?.metricType || null;
+    }
+    if (criteriaFilter.checkOn === CheckOn.DatabaseIsOnline) {
+      return MonitorMetricType.IsOnline;
+    }
+    return this.getMonitorMetricTypeByCheckOnOrNull(criteriaFilter.checkOn);
+  }
 }
 export default MonitorMetricTypeUtil;

package/Utils/Monitor/NetworkTopologyUtil.ts CHANGED Viewed

@@ -42,6 +42,21 @@ export interface TopologyDeviceInput {
   lastPolledAt?: Date | undefined;
   lastSeenAt?: Date | undefined;
   pollingIntervalInMinutes?: number | undefined;
+  /*
+   * How this device's health is established. NULL, empty and anything
+   * unrecognised read as Probe — see NetworkDeviceMonitoringMethodUtil.parse,
+   * which is why an omitted value keeps every existing caller on the poll
+   * rule unchanged.
+   *
+   * Read only when `monitorStatus` below is absent, and load-bearing there:
+   * a monitor-backed device (monitoringMethod "Monitor") with nothing
+   * stamped yet is drawn "unknown", which is what the device list says
+   * about it too. Without this the poll columns above would decide — and on
+   * a device switched over from SNMP they hold the last thing a probe found
+   * before it stopped asking, so a months-old lastSeenAt would draw the node
+   * red while its row in the device list reads Pending.
+   */
+  monitoringMethod?: string | null | undefined;
   interfacesUp?: number | undefined;
   interfacesDown?: number | undefined;
   vendor?: string | undefined;
@@ -1654,9 +1669,13 @@ export default class NetworkTopologyUtil {
   /*
    * The shared reachability rule (DeviceReachabilityUtil), mapped onto the
-   * graph's three node states. "Pending" — never polled — is the graph's
-   * "unknown", which is what keeps a device nothing walks from being drawn
-   * as a failure.
+   * graph's three node states. "Pending" — never polled, or monitor-backed
+   * with nothing reported yet — is the graph's "unknown", which is what
+   * keeps a device nothing walks from being drawn as a failure.
+   *
+   * Only reached with no stamped status (deviceStatus took every stamped
+   * one), so the monitoring method is the one fact left that tells the rule
+   * whether the poll columns are evidence or leftovers.
    */
   private static statusFromPoll(
     device: TopologyDeviceInput,
@@ -1668,6 +1687,7 @@ export default class NetworkTopologyUtil {
         lastPolledAt: device.lastPolledAt,
         lastSeenAt: device.lastSeenAt,
         pollingIntervalInMinutes: device.pollingIntervalInMinutes,
+        monitoringMethod: device.monitoringMethod,
       },
       now,
     );