@oneuptime/common 14.0.2 → 14.0.5

package/Server/Utils/Monitor/SeriesResourceLinker.ts

@@ -1,4 +1,6 @@
 import CephCluster from "../../../Models/DatabaseModels/CephCluster";
+import DatabaseServer from "../../../Models/DatabaseModels/DatabaseServer";
+import DatabaseServerEndpoint from "../../../Models/DatabaseModels/DatabaseServerEndpoint";
 import DockerHost from "../../../Models/DatabaseModels/DockerHost";
 import DockerSwarmCluster from "../../../Models/DatabaseModels/DockerSwarmCluster";
 import Host from "../../../Models/DatabaseModels/Host";
@@ -14,6 +16,8 @@ import { JSONObject } from "../../../Types/JSON";
 import MonitorType from "../../../Types/Monitor/MonitorType";
 import ObjectID from "../../../Types/ObjectID";
 import CephClusterService from "../../Services/CephClusterService";
+import DatabaseServerEndpointService from "../../Services/DatabaseServerEndpointService";
+import DatabaseServerService from "../../Services/DatabaseServerService";
 import DockerHostService from "../../Services/DockerHostService";
 import DockerSwarmClusterService from "../../Services/DockerSwarmClusterService";
 import HostService from "../../Services/HostService";
@@ -69,6 +73,7 @@ export interface SeriesLinkableModel {
   cephClusters?: Array<CephCluster> | undefined;
   dockerSwarmClusters?: Array<DockerSwarmCluster> | undefined;
   iotFleets?: Array<IoTFleet> | undefined;
+  databaseServers?: Array<DatabaseServer> | undefined;
 }
 
 /*
@@ -86,6 +91,7 @@ export interface SeriesResolvedResourceIds {
   cephClusterIds: Array<string>;
   dockerSwarmClusterIds: Array<string>;
   iotFleetIds: Array<string>;
+  databaseServerIds: Array<string>;
 }
 
 /*
@@ -171,7 +177,14 @@ export default class SeriesResourceLinker {
      * Proxmox / VMware / Ceph / Docker Swarm / IoT carry no
      * `oneuptime.*.id` stamp at ingest — they are addressable by name
      * only — so their `ids` lists are empty by construction, not by
-     * omission.
+     * omission. Databases are the reverse: never addressable by name (see
+     * DatabaseServerIdLabelKeys), so their `names` list is empty — they
+     * resolve by the `oneuptime.database.server.id` stamp here, and by an
+     * endpoint they own through the DatabaseServerEndpoint table below
+     * (the endpoint lives on a separate table, so it cannot be a spec).
+     *
+     * The Promise.all below destructures by POSITION: a new entry goes at
+     * the end of this list AND at the end of that destructure.
      */
     const specs: Array<ResourceResolutionSpec> = [
       {
@@ -236,8 +249,33 @@ export default class SeriesResourceLinker {
         nameColumn: "name",
         findBy: IoTFleetService.findBy.bind(IoTFleetService),
       },
+      {
+        ids: refs.databaseServerIds,
+        names: [],
+        nameColumn: "name",
+        findBy: DatabaseServerService.findBy.bind(DatabaseServerService),
+      },
     ];
 
+    const [resolvedBySpec, databaseServerIdsByEndpoint] = await Promise.all([
+      Promise.all(
+        specs.map((spec: ResourceResolutionSpec): Promise<Array<string>> => {
+          return this.resolveResourceIds({
+            ids: spec.ids,
+            names: spec.names,
+            nameColumn: spec.nameColumn,
+            projectId: input.projectId,
+            nameMatch: input.nameMatch,
+            findBy: spec.findBy,
+          });
+        }),
+      ),
+      this.resolveDatabaseServerIdsByEndpoint({
+        endpoints: refs.databaseServerEndpoints || [],
+        projectId: input.projectId,
+      }),
+    ]);
+
     const [
       hostIds,
       dockerHostIds,
@@ -249,17 +287,18 @@ export default class SeriesResourceLinker {
       cephClusterIds,
       dockerSwarmClusterIds,
       iotFleetIds,
-    ] = await Promise.all(
-      specs.map((spec: ResourceResolutionSpec): Promise<Array<string>> => {
-        return this.resolveResourceIds({
-          ids: spec.ids,
-          names: spec.names,
-          nameColumn: spec.nameColumn,
-          projectId: input.projectId,
-          nameMatch: input.nameMatch,
-          findBy: spec.findBy,
-        });
-      }),
+      databaseServerIdsById,
+    ] = resolvedBySpec;
+
+    /*
+     * A database can be named twice — by its id stamp and by an endpoint it
+     * owns — so the two answers are unioned, not concatenated.
+     */
+    const databaseServerIds: Array<string> = Array.from(
+      new Set<string>([
+        ...(databaseServerIdsById || []),
+        ...databaseServerIdsByEndpoint,
+      ]),
     );
 
     return {
@@ -273,9 +312,59 @@ export default class SeriesResourceLinker {
       cephClusterIds: cephClusterIds || [],
       dockerSwarmClusterIds: dockerSwarmClusterIds || [],
       iotFleetIds: iotFleetIds || [],
+      databaseServerIds: databaseServerIds,
     };
   }
 
+  /*
+   * The databases that own these canonical endpoints in this project.
+   *
+   * An exact match on DatabaseServerEndpoint.endpoint, which is stored in the
+   * same canonical form the refs were built in (formatDatabaseEndpoint) —
+   * the (projectId, endpoint) unique index guarantees at most one owner per
+   * endpoint, so an endpoint can never link two databases. Project-scoped
+   * like every other lookup here; costs zero round-trips when the monitor
+   * names no endpoint, which is every monitor that is not about a database.
+   */
+  private static async resolveDatabaseServerIdsByEndpoint(input: {
+    endpoints: Array<string>;
+    projectId: ObjectID;
+  }): Promise<Array<string>> {
+    const endpoints: Array<string> = Array.from(
+      new Set<string>(
+        input.endpoints.filter((endpoint: string): boolean => {
+          return typeof endpoint === "string" && endpoint.length > 0;
+        }),
+      ),
+    );
+
+    if (endpoints.length === 0) {
+      return [];
+    }
+
+    const rows: Array<DatabaseServerEndpoint> =
+      await DatabaseServerEndpointService.findBy({
+        query: {
+          projectId: input.projectId,
+          endpoint: new Includes(endpoints),
+        },
+        select: { _id: true, databaseServerId: true },
+        skip: 0,
+        limit: LIMIT_PER_PROJECT,
+        props: { isRoot: true },
+      });
+
+    const databaseServerIds: Set<string> = new Set<string>();
+
+    for (const row of rows) {
+      if (row.databaseServerId) {
+        databaseServerIds.add(row.databaseServerId.toString());
+      }
+    }
+
+    return Array.from(databaseServerIds);
+  }
+
   /*
    * Resolve the series' resources and MERGE them onto the alert/incident.
    * Merging (rather than assigning) matters because
@@ -437,6 +526,16 @@ export default class SeriesResourceLinker {
         },
       );
     }
+
+    if (resolved.databaseServerIds.length > 0) {
+      model.databaseServers = this.mergeById(
+        model.databaseServers,
+        resolved.databaseServerIds,
+        (): DatabaseServer => {
+          return new DatabaseServer();
+        },
+      );
+    }
   }
 
   /*

package/Server/Utils/Rules/RuleRun/RuleRunRegistry.ts

@@ -28,6 +28,11 @@ import DashboardLabelRule from "../../../../Models/DatabaseModels/DashboardLabel
 import DashboardOwnerRule from "../../../../Models/DatabaseModels/DashboardOwnerRule";
 import DashboardOwnerTeam from "../../../../Models/DatabaseModels/DashboardOwnerTeam";
 import DashboardOwnerUser from "../../../../Models/DatabaseModels/DashboardOwnerUser";
+import DatabaseServer from "../../../../Models/DatabaseModels/DatabaseServer";
+import DatabaseServerLabelRule from "../../../../Models/DatabaseModels/DatabaseServerLabelRule";
+import DatabaseServerOwnerRule from "../../../../Models/DatabaseModels/DatabaseServerOwnerRule";
+import DatabaseServerOwnerTeam from "../../../../Models/DatabaseModels/DatabaseServerOwnerTeam";
+import DatabaseServerOwnerUser from "../../../../Models/DatabaseModels/DatabaseServerOwnerUser";
 import DockerHost from "../../../../Models/DatabaseModels/DockerHost";
 import DockerHostLabelRule from "../../../../Models/DatabaseModels/DockerHostLabelRule";
 import DockerHostOwnerRule from "../../../../Models/DatabaseModels/DockerHostOwnerRule";
@@ -176,6 +181,11 @@ import DashboardLabelRuleService from "../../../Services/DashboardLabelRuleServi
 import DashboardOwnerRuleEngineService from "../../../Services/DashboardOwnerRuleEngineService";
 import DashboardOwnerRuleService from "../../../Services/DashboardOwnerRuleService";
 import DashboardService from "../../../Services/DashboardService";
+import DatabaseServerLabelRuleEngineService from "../../../Services/DatabaseServerLabelRuleEngineService";
+import DatabaseServerLabelRuleService from "../../../Services/DatabaseServerLabelRuleService";
+import DatabaseServerOwnerRuleEngineService from "../../../Services/DatabaseServerOwnerRuleEngineService";
+import DatabaseServerOwnerRuleService from "../../../Services/DatabaseServerOwnerRuleService";
+import DatabaseServerService from "../../../Services/DatabaseServerService";
 import DockerHostLabelRuleEngineService from "../../../Services/DockerHostLabelRuleEngineService";
 import DockerHostLabelRuleService from "../../../Services/DockerHostLabelRuleService";
 import DockerHostOwnerRuleEngineService from "../../../Services/DockerHostOwnerRuleEngineService";
@@ -440,6 +450,21 @@ const RULE_RUN_DEFINITIONS: Record<ResourceRuleRunType, RuleRunDefinition> = {
     engine: DashboardOwnerRuleEngineService,
     ownerModelTypes: [DashboardOwnerUser, DashboardOwnerTeam],
   }),
+  [RuleRunType.DatabaseServerLabelRule]: defineRuleRun({
+    ruleModelType: DatabaseServerLabelRule,
+    resourceModelType: DatabaseServer,
+    ruleService: DatabaseServerLabelRuleService,
+    resourceService: DatabaseServerService,
+    engine: DatabaseServerLabelRuleEngineService,
+  }),
+  [RuleRunType.DatabaseServerOwnerRule]: defineRuleRun({
+    ruleModelType: DatabaseServerOwnerRule,
+    resourceModelType: DatabaseServer,
+    ruleService: DatabaseServerOwnerRuleService,
+    resourceService: DatabaseServerService,
+    engine: DatabaseServerOwnerRuleEngineService,
+    ownerModelTypes: [DatabaseServerOwnerUser, DatabaseServerOwnerTeam],
+  }),
   [RuleRunType.DockerHostLabelRule]: defineRuleRun({
     ruleModelType: DockerHostLabelRule,
     resourceModelType: DockerHost,

package/Server/Utils/SessionReplay/SessionReplayGateCache.ts

@@ -90,6 +90,7 @@ const RUM_APPLICATION_POLICY_COLUMNS: ReadonlyArray<string> = [
   "sessionReplayMonthlyBudgetInGB",
   "sessionReplayIgnoreErrorPatterns",
   "sessionReplayTracePropagationOrigins",
+  "sessionReplaySameOriginTracePropagation",
   "sessionReplayLcpBudgetMs",
   "sessionReplayLongTaskBudgetMs",
   "sessionReplaySlowRequestBudgetMs",
@@ -159,11 +160,24 @@ export interface SessionReplayGatePolicy {
   ignoreErrorPatterns: Array<string>;
 
   /*
-   * Origins the recorder may inject a W3C traceparent header into.
-   * Empty = never inject; the empty default is the CORS safety mechanism.
+   * CROSS-origin APIs the recorder may inject a W3C traceparent header
+   * into (traceparent only, never the session id). Empty = no cross-origin
+   * injection; the empty default is the CORS safety mechanism. The page's
+   * own origin is governed by sameOriginTracePropagation, not by this list.
    */
   tracePropagationOrigins: Array<string>;
 
+  /*
+   * Whether the recorder adds traceparent plus a tracestate member carrying
+   * the replay session id to requests to the page's OWN origin while a
+   * session uploads, so the backend telemetry they cause links to the
+   * recording with no customer code. A same-origin request is never
+   * preflighted, so this defaults ON; the switch exists to turn it off
+   * without a customer redeploy (a same-origin request that redirects to
+   * another origin does need that origin to allow the headers).
+   */
+  sameOriginTracePropagation: boolean;
+
   /* Performance capture budgets in milliseconds; 0 disables each. */
   lcpBudgetMs: number;
   longTaskBudgetMs: number;
@@ -514,6 +528,14 @@ export default class SessionReplayGateCache {
         tracePropagationOrigins: this.readStringArray(
           appView["sessionReplayTracePropagationOrigins"],
         ),
+        /*
+         * Anything but an explicit false reads as on: the column defaults
+         * to true, so an absent or null value is the model default, like
+         * the consent / trigger / sample fallbacks above. Only an operator
+         * who switched it off gets it off.
+         */
+        sameOriginTracePropagation:
+          appView["sessionReplaySameOriginTracePropagation"] !== false,
         lcpBudgetMs: this.readNumber(appView["sessionReplayLcpBudgetMs"], 0),
         longTaskBudgetMs: this.readNumber(
           appView["sessionReplayLongTaskBudgetMs"],

package/Server/Utils/StartServer.ts

@@ -210,9 +210,33 @@ app.use((req: ExpressRequest, _res: ExpressResponse, next: NextFunction) => {
  * Parse protobuf (binary) bodies for non-OTLP routes.
  * OTLP HTTP ingestion bypasses the global body parsers and handles raw/gzip
  * payloads in the telemetry router to avoid conflicts with the merged app stack.
+ *
+ * "application/proto" is the Connect protocol's spelling. Grafana Alloy's
+ * pyroscope.write and pyroscope-dotnet v0.14+ post their push.v1 requests
+ * with it, uncompressed; without it here the body fell through to the JSON
+ * parser, stayed {} and every such push was answered 400.
  */
+export const PROTOBUF_CONTENT_TYPES: Array<string> = [
+  "application/x-protobuf",
+  "application/protobuf",
+  "application/proto",
+];
+
+export const isProtobufContentType: (
+  contentType: string | undefined,
+) => boolean = (contentType: string | undefined): boolean => {
+  if (!contentType) {
+    return false;
+  }
+
+  // Media types are case-insensitive, and may carry parameters.
+  const mediaType: string = contentType.split(";")[0]!.trim().toLowerCase();
+
+  return PROTOBUF_CONTENT_TYPES.includes(mediaType);
+};
+
 const protobufBodyParserMiddleware: RequestHandler = ExpressRaw({
-  type: ["application/x-protobuf", "application/protobuf"],
+  type: PROTOBUF_CONTENT_TYPES,
   limit: "50mb",
 });
 
@@ -249,11 +273,7 @@ app.use((req: OneUptimeRequest, res: ExpressResponse, next: NextFunction) => {
      * turned 130 KB of anonymous request into 128 MiB of resident Buffer.
      */
     GzipRequestBodyMiddleware.parseBody(req, res, next);
-  } else if (
-    contentType &&
-    (contentType.includes("application/x-protobuf") ||
-      contentType.includes("application/protobuf"))
-  ) {
+  } else if (isProtobufContentType(contentType)) {
     protobufBodyParserMiddleware(req, res, next);
   } else {
     jsonBodyParserMiddleware(req, res, next);

package/Server/Utils/TeamMember/ProjectLeaveResourceCleanup.ts

@@ -15,6 +15,7 @@ import CephClusterOwnerUserService from "../../Services/CephClusterOwnerUserServ
 import CloudResourceOwnerUserService from "../../Services/CloudResourceOwnerUserService";
 import DashboardOwnerUserService from "../../Services/DashboardOwnerUserService";
 import DatabaseService from "../../Services/DatabaseService";
+import DatabaseServerOwnerUserService from "../../Services/DatabaseServerOwnerUserService";
 import DockerHostOwnerUserService from "../../Services/DockerHostOwnerUserService";
 import DockerSwarmClusterOwnerUserService from "../../Services/DockerSwarmClusterOwnerUserService";
 import HostOwnerUserService from "../../Services/HostOwnerUserService";
@@ -147,6 +148,7 @@ export default class ProjectLeaveResourceCleanup {
       ownerUserTable(CephClusterOwnerUserService, "cephClusterId"),
       ownerUserTable(CloudResourceOwnerUserService, "cloudResourceId"),
       ownerUserTable(DashboardOwnerUserService, "dashboardId"),
+      ownerUserTable(DatabaseServerOwnerUserService, "databaseServerId"),
       ownerUserTable(DockerHostOwnerUserService, "dockerHostId"),
       ownerUserTable(
         DockerSwarmClusterOwnerUserService,