@oneuptime/common 12.0.12 → 12.0.14

package/Server/Utils/Monitor/SeriesResourceLinker.ts

@@ -10,6 +10,7 @@ import Service from "../../../Models/DatabaseModels/Service";
 import Includes from "../../../Types/BaseDatabase/Includes";
 import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
 import { JSONObject } from "../../../Types/JSON";
+import MonitorType from "../../../Types/Monitor/MonitorType";
 import ObjectID from "../../../Types/ObjectID";
 import CephClusterService from "../../Services/CephClusterService";
 import DockerHostService from "../../Services/DockerHostService";
@@ -20,11 +21,18 @@ import KubernetesClusterService from "../../Services/KubernetesClusterService";
 import PodmanHostService from "../../Services/PodmanHostService";
 import ProxmoxClusterService from "../../Services/ProxmoxClusterService";
 import ServiceService from "../../Services/ServiceService";
-import { MonitorClusterContext } from "./MonitorClusterContext";
+import QueryHelper from "../../Types/Database/QueryHelper";
 import SeriesResourceLabels, {
   SeriesResourceRefs,
 } from "./SeriesResourceLabels";
 
+/*
+ * How a resource's NAME is matched against its identifier column.
+ * Ingest-written series labels match byte for byte; user-typed monitor
+ * step identifiers may differ from the agent-stamped name by case.
+ */
+export type NameMatchMode = "exact" | "caseInsensitive";
+
 /*
  * A grouped monitor opens one alert/incident per breaching series, and
  * each series carries the identity of the resource it came from in its
@@ -100,11 +108,61 @@ export default class SeriesResourceLinker {
   public static async resolveResourcesFromSeriesLabels(input: {
     seriesLabels: JSONObject;
     projectId: ObjectID;
+    /*
+     * Optional, and only consulted to disambiguate `host.name`. Left
+     * undefined by callers that have no monitor in hand.
+     */
+    monitorType?: MonitorType | undefined;
   }): Promise<SeriesResolvedResourceIds> {
     const refs: SeriesResourceRefs = SeriesResourceLabels.extractResourceRefs(
       input.seriesLabels,
     );
 
+    /*
+     * On a Docker or Podman monitor, `resource.host.name` names the
+     * DockerHost / PodmanHost the containers run on — the agent stamps
+     * the container runtime's host under the generic key. The label key
+     * map hands that key to Host, which would attach an unrelated Host
+     * row and surface the event on that host's Activity tab. The
+     * step-config path links the right model instead
+     * (MonitorStepResourceIdentity), so drop the host refs here rather
+     * than linking a resource the event is not about.
+     */
+    if (
+      input.monitorType === MonitorType.Docker ||
+      input.monitorType === MonitorType.Podman
+    ) {
+      refs.hostIds = [];
+      refs.hostNames = [];
+    }
+
+    /*
+     * Series labels are ingest-written, so they match the resource
+     * rows' identifier columns byte for byte. See resolveResourceIds
+     * for why that rules out case-insensitive matching here.
+     */
+    return this.resolveResourceRefs({
+      refs: refs,
+      projectId: input.projectId,
+      nameMatch: "exact",
+    });
+  }
+
+  /*
+   * The one place that turns identifiers into database ids, shared by
+   * the series-label path and the monitor-step-config path
+   * (MonitorStepResourceIdentity). Keeping the nine-way lookup table,
+   * the project scoping and the `Includes` batching in a single
+   * function is what stops the two paths from resolving the same
+   * identifier to different rows.
+   */
+  public static async resolveResourceRefs(input: {
+    refs: SeriesResourceRefs;
+    projectId: ObjectID;
+    nameMatch: NameMatchMode;
+  }): Promise<SeriesResolvedResourceIds> {
+    const refs: SeriesResourceRefs = input.refs;
+
     /*
      * Proxmox / Ceph / Docker Swarm / IoT carry no `oneuptime.*.id`
      * stamp at ingest — they are addressable by name only — so their
@@ -186,6 +244,7 @@ export default class SeriesResourceLinker {
           names: spec.names,
           nameColumn: spec.nameColumn,
           projectId: input.projectId,
+          nameMatch: input.nameMatch,
           findBy: spec.findBy,
         });
       }),
@@ -206,9 +265,10 @@ export default class SeriesResourceLinker {
 
   /*
    * Resolve the series' resources and MERGE them onto the alert/incident.
-   * Merging (rather than assigning) matters because attachClusterContext
-   * writes the same four cluster relations from the monitor's step
-   * config; whichever runs second must not erase the other's work.
+   * Merging (rather than assigning) matters because
+   * attachResolvedResources writes the same relations from the
+   * monitor's step config; whichever runs second must not erase the
+   * other's work.
    *
    * Relations the series says nothing about are left untouched —
    * `undefined`, not `[]` — so an ungrouped event and an event whose
@@ -223,11 +283,17 @@ export default class SeriesResourceLinker {
     model: SeriesLinkableModel;
     seriesLabels: JSONObject;
     projectId: ObjectID;
+    /*
+     * Optional, and only consulted to disambiguate `host.name`. Left
+     * undefined by callers that have no monitor in hand.
+     */
+    monitorType?: MonitorType | undefined;
   }): Promise<void> {
     const resolved: SeriesResolvedResourceIds =
       await this.resolveResourcesFromSeriesLabels({
         seriesLabels: input.seriesLabels,
         projectId: input.projectId,
+        monitorType: input.monitorType,
       });
 
     this.mergeResolvedIdsIntoModel({
@@ -237,30 +303,22 @@ export default class SeriesResourceLinker {
   }
 
   /*
-   * Attach the cluster ids resolved from the monitor's step config
-   * (Proxmox / Ceph / Docker Swarm / IoT), merging with — never
-   * overwriting — anything the series-label path already linked. Both
-   * paths can resolve the same cluster, so this dedupes by id. Unlike
-   * the label path this runs for ungrouped events too: those monitor
-   * types get their cluster identity from the step config alone.
+   * Attach the resources resolved from the monitor's own step config
+   * (MonitorResourceContext), merging with — never overwriting —
+   * anything the series-label path already linked. Both paths can
+   * resolve the same resource, so this dedupes by id.
+   *
+   * Unlike the label path this runs for ungrouped events too, and that
+   * is the whole point: an ungrouped monitor has no series labels, so
+   * before this existed it linked nothing at all.
    */
-  public static attachClusterContext(input: {
+  public static attachResolvedResources(input: {
     model: SeriesLinkableModel;
-    clusterContext: MonitorClusterContext;
+    resolved: SeriesResolvedResourceIds;
   }): void {
     this.mergeResolvedIdsIntoModel({
       model: input.model,
-      resolved: {
-        hostIds: [],
-        dockerHostIds: [],
-        podmanHostIds: [],
-        kubernetesClusterIds: [],
-        serviceIds: [],
-        proxmoxClusterIds: input.clusterContext.proxmoxClusterIds,
-        cephClusterIds: input.clusterContext.cephClusterIds,
-        dockerSwarmClusterIds: input.clusterContext.dockerSwarmClusterIds,
-        iotFleetIds: input.clusterContext.iotFleetIds,
-      },
+      resolved: input.resolved,
     });
   }
 
@@ -396,16 +454,23 @@ export default class SeriesResourceLinker {
    * Costs zero round-trips when the series carries neither, which is the
    * common case for most of the nine types on any given series.
    *
-   * Name matching is exact. Every identifier column read here is written
-   * by ingest from the same attribute the series label carries — host
-   * identifiers are canonicalized on both sides — so exact matching is
-   * what keeps a lookup from straying onto a neighbouring row.
+   * `nameMatch: "exact"` is for series labels. Every identifier column
+   * read here is written by ingest from the same attribute the series
+   * label carries — host identifiers are canonicalized on both sides —
+   * so exact matching is what keeps a lookup from straying onto a
+   * neighbouring row.
+   *
+   * `nameMatch: "caseInsensitive"` is for monitor step configs, where
+   * the identifier was typed by a user and the row's name was stamped
+   * by an agent; the two legitimately differ by case. This mirrors what
+   * ingest discovery itself does when it keys a row by name.
    */
   private static async resolveResourceIds(input: {
     ids: Array<string>;
     names: Array<string>;
     nameColumn: string;
     projectId: ObjectID;
+    nameMatch: NameMatchMode;
     /*
      * Loosely typed because each resource service has its own
      * `Query<TBaseModel>` shape and we deliberately abstract over
@@ -443,7 +508,10 @@ export default class SeriesResourceLinker {
         input.findBy({
           query: {
             projectId: input.projectId,
-            [input.nameColumn]: new Includes(input.names),
+            [input.nameColumn]:
+              input.nameMatch === "caseInsensitive"
+                ? QueryHelper.findWithSameTextAnyOf(input.names)
+                : new Includes(input.names),
           },
           select: { _id: true },
           skip: 0,

package/Server/Utils/SessionReplay/SessionReplayGateCacheStore.ts

@@ -24,6 +24,15 @@ import ObjectID from "../../../Types/ObjectID";
 export const POLICY_CACHE_TTL_MS: number = 60 * 1000;
 export const KILL_KEY_CACHE_TTL_MS: number = 5 * 1000;
 
+/*
+ * The policy cache key includes a client-supplied appIdentifier, so without a
+ * bound anyone holding an ingestion key could grow this map forever. Caps
+ * match the InMemoryTTLCache house default; that class is not used directly
+ * because clearCache(projectId) needs the prefix key scan it lacks.
+ */
+export const MAX_POLICY_CACHE_ENTRIES: number = 10_000;
+export const MAX_KILL_KEY_CACHE_ENTRIES: number = 10_000;
+
 const KILL_KEY_PREFIX: string = "replay:gate:off:";
 
 /*
@@ -52,6 +61,29 @@ interface KillKeyCacheEntry {
 const policyCache: Map<string, PolicyCacheEntry<unknown>> = new Map();
 const killKeyCache: Map<string, KillKeyCacheEntry> = new Map();
 
+/*
+ * Coarse-LRU bounded write (mirrors InMemoryTTLCache): evict the oldest entry
+ * only when at capacity AND the key is new, so rewriting an existing key never
+ * evicts a different entry; delete-before-set refreshes insertion order. The
+ * entry being written always lands, which markProjectDisabled's local kill
+ * marker depends on.
+ */
+function boundedSet<TValue>(
+  map: Map<string, TValue>,
+  key: string,
+  value: TValue,
+  maxEntries: number,
+): void {
+  if (map.size >= maxEntries && !map.has(key)) {
+    const oldest: string | undefined = map.keys().next().value;
+    if (oldest !== undefined) {
+      map.delete(oldest);
+    }
+  }
+  map.delete(key);
+  map.set(key, value);
+}
+
 export default class SessionReplayGateCacheStore {
   public static getPolicyEntry<TPolicy>(
     cacheKey: string,
@@ -63,7 +95,12 @@ export default class SessionReplayGateCacheStore {
     cacheKey: string,
     policy: TPolicy | null,
   ): void {
-    policyCache.set(cacheKey, { policy: policy, loadedAt: Date.now() });
+    boundedSet(
+      policyCache,
+      cacheKey,
+      { policy: policy, loadedAt: Date.now() },
+      MAX_POLICY_CACHE_ENTRIES,
+    );
   }
 
   /*
@@ -93,10 +130,12 @@ export default class SessionReplayGateCacheStore {
       }
     }
 
-    killKeyCache.set(projectId.toString(), {
-      isDisabled: true,
-      loadedAt: Date.now(),
-    });
+    boundedSet(
+      killKeyCache,
+      projectId.toString(),
+      { isDisabled: true, loadedAt: Date.now() },
+      MAX_KILL_KEY_CACHE_ENTRIES,
+    );
   }
 
   /*
@@ -159,7 +198,12 @@ export default class SessionReplayGateCacheStore {
        * Failing closed here would make a Redis blip stop replay ingest for
        * every project that had correctly opted in.
        */
-      killKeyCache.set(cacheKey, { isDisabled: false, loadedAt: Date.now() });
+      boundedSet(
+        killKeyCache,
+        cacheKey,
+        { isDisabled: false, loadedAt: Date.now() },
+        MAX_KILL_KEY_CACHE_ENTRIES,
+      );
       return false;
     }
 
@@ -178,10 +222,12 @@ export default class SessionReplayGateCacheStore {
       isDisabled = false;
     }
 
-    killKeyCache.set(cacheKey, {
-      isDisabled: isDisabled,
-      loadedAt: Date.now(),
-    });
+    boundedSet(
+      killKeyCache,
+      cacheKey,
+      { isDisabled: isDisabled, loadedAt: Date.now() },
+      MAX_KILL_KEY_CACHE_ENTRIES,
+    );
 
     return isDisabled;
   }

package/Server/Utils/StartServer.ts

@@ -76,30 +76,51 @@ app.set("view engine", "ejs");
 app.set("trust proxy", TrustedProxyHops);
 app.use(CookieParser());
 
-const jsonBodyParserMiddleware: RequestHandler = ExpressJson({
+export type BodyParserVerify = (
+  req: ExpressRequest,
+  res: ExpressResponse,
+  buf: Buffer,
+) => void;
+
+export interface BodyParserOptions {
+  limit: string;
+  extended: boolean;
+  verify: BodyParserVerify;
+}
+
+export const jsonBodyParserOptions: BodyParserOptions = {
   limit: "50mb",
   extended: true,
-  verify: (req: ExpressRequest, _res: ExpressResponse, buf: Buffer) => {
+  verify: (req: ExpressRequest, _res: ExpressResponse, buf: Buffer): void => {
     (req as OneUptimeRequest).rawBody = buf.toString();
     logger.debug(
       `Raw JSON Body for signature verification captured`,
       getLogAttributesFromRequest(req as OneUptimeRequest),
     );
   },
-}); // 50 MB limit.
+};
+
+const jsonBodyParserMiddleware: RequestHandler = ExpressJson(
+  jsonBodyParserOptions,
+); // 50 MB limit.
 
-const urlEncodedMiddleware: RequestHandler = ExpressUrlEncoded({
+export const urlEncodedBodyParserOptions: BodyParserOptions = {
   limit: "50mb",
   extended: true,
-  verify: (req: ExpressRequest, _res: ExpressResponse, buf: Buffer) => {
-    (req as OneUptimeRequest).rawFormUrlEncodedBody = buf.toString();
-    (req as OneUptimeRequest).rawBody = buf.toString(); // Also set rawBody for consistency
+  verify: (req: ExpressRequest, _res: ExpressResponse, buf: Buffer): void => {
+    const raw: string = buf.toString();
+    (req as OneUptimeRequest).rawFormUrlEncodedBody = raw;
+    (req as OneUptimeRequest).rawBody = raw; // Also set rawBody for consistency
     logger.debug(
-      `Raw Form Url Encoded Body: ${(req as OneUptimeRequest).rawFormUrlEncodedBody}`,
+      `Raw Form Url Encoded Body for signature verification captured`,
       getLogAttributesFromRequest(req as OneUptimeRequest),
     );
   },
-}); // 50 MB limit.
+};
+
+const urlEncodedMiddleware: RequestHandler = ExpressUrlEncoded(
+  urlEncodedBodyParserOptions,
+); // 50 MB limit.
 
 const setDefaultHeaders: RequestHandler = (
   req: ExpressRequest,

package/Server/Utils/StatusPageSearchEngineIndexing.ts

@@ -0,0 +1,33 @@
+import { ExpressResponse } from "./Express";
+import {
+  NOINDEX_ROBOTS_DIRECTIVE,
+  X_ROBOTS_TAG_HEADER_NAME,
+} from "../../Types/StatusPage/SearchEngineIndexing";
+
+/**
+ * Sets X-Robots-Tag: noindex, nofollow when the status page has search engine
+ * indexing turned off, and sets nothing at all when it is on.
+ *
+ * The "sets nothing" half is the point. An explicit `index, follow` header
+ * would be the default behaviour restated, and it would also override a
+ * noindex that an operator put in front of OneUptime (a CDN rule, an ingress
+ * annotation) - headers do not merge, the last writer wins. Staying silent
+ * leaves those in place.
+ *
+ * Callers must invoke this before the response is sent; a header set after
+ * headers are flushed is dropped by Node, silently.
+ */
+export default function applyStatusPageRobotsHeader(
+  res: ExpressResponse,
+  isSearchEngineIndexingEnabled: boolean,
+): void {
+  if (isSearchEngineIndexingEnabled) {
+    return;
+  }
+
+  if (res.headersSent) {
+    return;
+  }
+
+  res.set(X_ROBOTS_TAG_HEADER_NAME, NOINDEX_ROBOTS_DIRECTIVE);
+}