@oneuptime/common 13.0.4 → 13.0.6

package/build/dist/Server/Services/AuditLogService.js

@@ -1,17 +1,27 @@
 import AnalyticsDatabaseService from "./AnalyticsDatabaseService";
+import DatabaseService from "./DatabaseService";
 import ProjectService from "./ProjectService";
 import { IsBillingEnabled, IsEnterpriseEdition } from "../EnvironmentConfig";
+import QueryHelper from "../Types/Database/QueryHelper";
+import RelationValueUtil from "../Utils/Database/RelationValueUtil";
 import logger from "../Utils/Logger";
 import AuditLog from "../../Models/AnalyticsModels/AuditLog";
+import User from "../../Models/DatabaseModels/User";
 import AuditLogAction from "../../Types/AuditLog/AuditLogAction";
 import { PlanType } from "../../Types/Billing/SubscriptionPlan";
 import { getColumnAccessControlForAllColumns } from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableColumnType from "../../Types/Database/TableColumnType";
 import ObjectID from "../../Types/ObjectID";
 import UserType from "../../Types/UserType";
 import UserService from "./UserService";
 import OneUptimeDate from "../../Types/Date";
 const PROJECT_SETTINGS_CACHE_TTL_MS = 60 * 1000;
 const USER_CACHE_TTL_MS = 5 * 60 * 1000;
+/*
+ * Upper bound on the related rows one audit entry looks up to name. An entry
+ * that references more is still recorded in full; the rest keep their ids.
+ */
+const MAX_RELATION_NAME_LOOKUPS = 100;
 const SKIPPED_FIELDS = new Set([
     "_id",
     "id",
@@ -31,6 +41,7 @@ export class AuditLogService extends AnalyticsDatabaseService {
         super({ modelType: AuditLog, database: clickhouseDatabase });
         this.projectSettingsCache = new Map();
         this.userCache = new Map();
+        this.relatedModelServices = new Map();
     }
     invalidateProjectSettings(projectId) {
         this.projectSettingsCache.delete(projectId.toString());
@@ -46,17 +57,21 @@ export class AuditLogService extends AnalyticsDatabaseService {
             if (!this.isEligible(settings, data.props)) {
                 return;
             }
-            const redactedFields = this.getRedactedFields(data.model);
             const changes = this.buildSnapshotChanges({
-                model: data.createdItem,
-                redactedFields,
+                model: data.model,
+                item: data.createdItem,
                 valueKey: "newValue",
             });
+            await this.addRelationNames({
+                model: data.model,
+                changes,
+                projectId,
+            });
             await this.insert({
                 projectId,
-                resourceType: this.getResourceType(data.model),
+                model: data.model,
+                item: data.createdItem,
                 resourceId: (_a = data.createdItem.id) !== null && _a !== void 0 ? _a : null,
-                resourceName: this.getResourceName(data.createdItem),
                 action: AuditLogAction.Create,
                 changes,
                 props: data.props,
@@ -70,6 +85,20 @@ export class AuditLogService extends AnalyticsDatabaseService {
     }
     async recordUpdate(data) {
         try {
+            /*
+             * The diff comes first because it needs no I/O: an update that changed
+             * nothing the audit trail tracks - an evaluation tick that rewrote only
+             * ignored columns, several times an hour per SLO - should not cost a
+             * settings lookup.
+             */
+            const changes = this.buildUpdateDiff({
+                model: data.model,
+                before: data.before,
+                updatedFields: data.updatedFields,
+            });
+            if (changes.length === 0) {
+                return;
+            }
             const projectId = this.resolveProjectId(data.model, data.before, data.props);
             if (!projectId) {
                 return;
@@ -78,20 +107,16 @@ export class AuditLogService extends AnalyticsDatabaseService {
             if (!this.isEligible(settings, data.props)) {
                 return;
             }
-            const redactedFields = this.getRedactedFields(data.model);
-            const changes = this.buildUpdateDiff({
-                before: data.before,
-                updatedFields: data.updatedFields,
-                redactedFields,
+            await this.addRelationNames({
+                model: data.model,
+                changes,
+                projectId,
             });
-            if (changes.length === 0) {
-                return;
-            }
             await this.insert({
                 projectId,
-                resourceType: this.getResourceType(data.model),
+                model: data.model,
+                item: data.before,
                 resourceId: data.itemId,
-                resourceName: this.getResourceName(data.before),
                 action: AuditLogAction.Update,
                 changes,
                 props: data.props,
@@ -113,17 +138,21 @@ export class AuditLogService extends AnalyticsDatabaseService {
             if (!this.isEligible(settings, data.props)) {
                 return;
             }
-            const redactedFields = this.getRedactedFields(data.model);
             const changes = this.buildSnapshotChanges({
-                model: data.deletedItem,
-                redactedFields,
+                model: data.model,
+                item: data.deletedItem,
                 valueKey: "oldValue",
             });
+            await this.addRelationNames({
+                model: data.model,
+                changes,
+                projectId,
+            });
             await this.insert({
                 projectId,
-                resourceType: this.getResourceType(data.model),
+                model: data.model,
+                item: data.deletedItem,
                 resourceId: data.itemId,
-                resourceName: this.getResourceName(data.deletedItem),
                 action: AuditLogAction.Delete,
                 changes,
                 props: data.props,
@@ -136,14 +165,30 @@ export class AuditLogService extends AnalyticsDatabaseService {
         }
     }
     async insert(params) {
+        const resourceType = this.getResourceType(params.model);
+        const resourceName = await this.resolveResourceName({
+            model: params.model,
+            item: params.item,
+            projectId: params.projectId,
+        });
+        const rootResource = this.getRootResource({
+            model: params.model,
+            item: params.item,
+            resourceType,
+            resourceId: params.resourceId,
+        });
         const auditLog = new AuditLog();
         auditLog.projectId = params.projectId;
-        auditLog.resourceType = params.resourceType;
+        auditLog.resourceType = resourceType;
         if (params.resourceId) {
             auditLog.resourceId = params.resourceId;
         }
-        if (params.resourceName) {
-            auditLog.resourceName = params.resourceName;
+        if (resourceName) {
+            auditLog.resourceName = resourceName;
+        }
+        if (rootResource.rootResourceType && rootResource.rootResourceId) {
+            auditLog.rootResourceType = rootResource.rootResourceType;
+            auditLog.rootResourceId = rootResource.rootResourceId;
         }
         auditLog.action = params.action;
         const actor = await this.resolveActor(params.props);
@@ -297,6 +342,50 @@ export class AuditLogService extends AnalyticsDatabaseService {
         const value = item.getValue(tenantColumn);
         return value !== null && value !== void 0 ? value : undefined;
     }
+    /*
+     * Where this entry rolls up to (see EnableAuditLogOn.rootResource). A
+     * top-level resource points at itself; a child points at the parent id it
+     * carries in its configured column.
+     */
+    getRootResource(data) {
+        var _a;
+        const rootResource = (_a = data.model.enableAuditLogOn) === null || _a === void 0 ? void 0 : _a.rootResource;
+        if (!rootResource) {
+            return {
+                rootResourceType: data.resourceType,
+                rootResourceId: data.resourceId,
+            };
+        }
+        const rootResourceId = RelationValueUtil.getRelationId(data.item[rootResource.column]);
+        if (!rootResourceId) {
+            /*
+             * A child row that cannot name its parent. Filing it under itself would
+             * give it a root type it is not, so it gets no pointer: the entry still
+             * shows in the project-wide audit log, just not on a resource's page.
+             */
+            return { rootResourceType: null, rootResourceId: null };
+        }
+        return {
+            rootResourceType: rootResource.resourceType,
+            rootResourceId: new ObjectID(rootResourceId),
+        };
+    }
+    /*
+     * Everything an entry leaves out: bookkeeping fields, columns nobody may read
+     * (read ACL `[]`, so recording them would leak them to audit readers), and
+     * the model's ignored columns.
+     */
+    getExcludedFields(model) {
+        var _a;
+        const excluded = new Set(SKIPPED_FIELDS);
+        for (const field of this.getRedactedFields(model)) {
+            excluded.add(field);
+        }
+        for (const field of ((_a = model.enableAuditLogOn) === null || _a === void 0 ? void 0 : _a.ignoreColumns) || []) {
+            excluded.add(field);
+        }
+        return excluded;
+    }
     getRedactedFields(model) {
         const redacted = new Set();
         const allAccessControl = getColumnAccessControlForAllColumns(model);
@@ -310,48 +399,53 @@ export class AuditLogService extends AnalyticsDatabaseService {
     }
     buildSnapshotChanges(data) {
         const changes = [];
+        const excludedFields = this.getExcludedFields(data.model);
         const columns = data.model.getTableColumns().columns;
+        const itemRecord = data.item;
         for (const column of columns) {
-            if (SKIPPED_FIELDS.has(column)) {
+            if (excludedFields.has(column)) {
                 continue;
             }
-            if (data.redactedFields.has(column)) {
-                continue;
-            }
-            const value = data.model[column];
+            const value = itemRecord[column];
             if (value === undefined) {
                 continue;
             }
             changes.push({
                 field: column,
-                [data.valueKey]: this.serializeValue(value),
+                [data.valueKey]: this.serializeValue(data.model, column, value),
             });
         }
         return changes;
     }
     buildUpdateDiff(data) {
         const changes = [];
+        const excludedFields = this.getExcludedFields(data.model);
+        const beforeRecord = data.before;
         for (const field of Object.keys(data.updatedFields)) {
-            if (SKIPPED_FIELDS.has(field)) {
-                continue;
-            }
-            if (data.redactedFields.has(field)) {
+            if (excludedFields.has(field)) {
                 continue;
             }
             const newValue = data.updatedFields[field];
-            const oldValue = data.before[field];
-            if (this.areValuesEqual(oldValue, newValue)) {
+            const oldValue = beforeRecord[field];
+            if (this.areValuesEqual({
+                model: data.model,
+                field,
+                oldValue,
+                newValue,
+            })) {
                 continue;
             }
             changes.push({
                 field,
-                oldValue: this.serializeValue(oldValue),
-                newValue: this.serializeValue(newValue),
+                oldValue: this.serializeValue(data.model, field, oldValue),
+                newValue: this.serializeValue(data.model, field, newValue),
             });
         }
         return changes;
     }
-    areValuesEqual(a, b) {
+    areValuesEqual(data) {
+        const a = data.oldValue;
+        const b = data.newValue;
         if (a === b) {
             return true;
         }
@@ -361,6 +455,18 @@ export class AuditLogService extends AnalyticsDatabaseService {
         if (b === null || b === undefined) {
             return false;
         }
+        /*
+         * A relation is the set of rows it references. Its JSON also carries
+         * whatever else happened to be loaded - the before-row's names, the
+         * payload's bare ids, the order the join returned - so an unchanged
+         * relation would otherwise read as changed.
+         */
+        if (this.getRelationMetadata(data.model, data.field)) {
+            const sameRelationIds = RelationValueUtil.haveSameRelationIds(a, b);
+            if (sameRelationIds !== null) {
+                return sameRelationIds;
+            }
+        }
         try {
             return JSON.stringify(a) === JSON.stringify(b);
         }
@@ -368,7 +474,55 @@ export class AuditLogService extends AnalyticsDatabaseService {
             return false;
         }
     }
-    serializeValue(value) {
+    // The column's metadata when it is a relation (Entity / EntityArray), else null.
+    getRelationMetadata(model, field) {
+        if (!model.isTableColumn(field)) {
+            return null;
+        }
+        const metadata = model.getTableColumnMetadata(field);
+        if (!metadata ||
+            !metadata.modelType ||
+            (metadata.type !== TableColumnType.Entity &&
+                metadata.type !== TableColumnType.EntityArray)) {
+            return null;
+        }
+        return metadata;
+    }
+    serializeValue(model, field, value) {
+        if (value === null || value === undefined) {
+            return null;
+        }
+        /*
+         * A related row is recorded as `{ _id, name }`. Serialized as it arrives
+         * it would be a model instance's JSON: a bare `{ _id }` from a payload, or
+         * whatever columns the read happened to load.
+         */
+        if (this.getRelationMetadata(model, field)) {
+            if (Array.isArray(value)) {
+                return value.map((element) => {
+                    return this.serializeRelationReference(element);
+                });
+            }
+            return this.serializeRelationReference(value);
+        }
+        return this.serializePlainValue(value);
+    }
+    serializeRelationReference(value) {
+        const id = RelationValueUtil.getRelationId(value);
+        // Not a reference at all: record it as it is rather than drop it.
+        if (!id) {
+            return this.serializePlainValue(value);
+        }
+        const reference = { _id: id };
+        if (value && typeof value === "object") {
+            const name = this.toDisplayString(value["name"]);
+            if (name) {
+                reference["name"] = name;
+            }
+        }
+        return reference;
+    }
+    serializePlainValue(value) {
         if (value === null || value === undefined) {
             return null;
         }
@@ -390,6 +544,158 @@ export class AuditLogService extends AnalyticsDatabaseService {
             return String(value);
         }
     }
+    /*
+     * Relation references are recorded with names so an entry reads
+     * "Production -> Staging" rather than as two ids. An update's before-row
+     * already carries the old names (DatabaseService selects them), but a
+     * payload usually carries ids only - so an unnamed reference first borrows
+     * the name of another reference to the same row in the same change, and
+     * whatever is still unnamed is looked up. Best effort: a failed lookup leaves
+     * the ids, and never costs the entry.
+     */
+    async addRelationNames(data) {
+        const pendingByModel = new Map();
+        for (const change of data.changes) {
+            const entry = change;
+            const metadata = this.getRelationMetadata(data.model, String(entry["field"]));
+            if (!metadata || !metadata.modelType) {
+                continue;
+            }
+            const references = [
+                ...this.getRelationReferences(entry["oldValue"]),
+                ...this.getRelationReferences(entry["newValue"]),
+            ];
+            const knownNames = new Map();
+            for (const reference of references) {
+                const name = reference["name"];
+                if (typeof name === "string" && name.length > 0) {
+                    knownNames.set(String(reference["_id"]).toLowerCase(), name);
+                }
+            }
+            for (const reference of references) {
+                if (reference["name"]) {
+                    continue;
+                }
+                const id = String(reference["_id"]).toLowerCase();
+                const knownName = knownNames.get(id);
+                if (knownName) {
+                    reference["name"] = knownName;
+                    continue;
+                }
+                let pending = pendingByModel.get(metadata.modelType);
+                if (!pending) {
+                    pending = {
+                        modelType: metadata.modelType,
+                        ids: new Set(),
+                        references: [],
+                    };
+                    pendingByModel.set(metadata.modelType, pending);
+                }
+                pending.ids.add(id);
+                pending.references.push(reference);
+            }
+        }
+        let remainingLookups = MAX_RELATION_NAME_LOOKUPS;
+        for (const pending of pendingByModel.values()) {
+            if (remainingLookups <= 0) {
+                break;
+            }
+            const ids = Array.from(pending.ids).slice(0, remainingLookups);
+            remainingLookups -= ids.length;
+            try {
+                const names = await this.findRelationNames({
+                    modelType: pending.modelType,
+                    ids,
+                    projectId: data.projectId,
+                });
+                for (const reference of pending.references) {
+                    const name = names.get(String(reference["_id"]).toLowerCase());
+                    if (name) {
+                        reference["name"] = name;
+                    }
+                }
+            }
+            catch (err) {
+                logger.warn("AuditLog: could not resolve the names of related resources; recording their ids only");
+                logger.warn(err);
+            }
+        }
+    }
+    getRelationReferences(value) {
+        const candidates = Array.isArray(value) ? value : [value];
+        return candidates.filter((candidate) => {
+            return (candidate !== null &&
+                typeof candidate === "object" &&
+                !Array.isArray(candidate) &&
+                typeof candidate["_id"] === "string");
+        });
+    }
+    /*
+     * Display names for related rows, keyed by lower-cased id.
+     *
+     * A user is named by their name, else their email, through the same cache
+     * the actor lookup uses. Any other model is named by its `name` column, and
+     * only rows inside the audited project are read: the ids come from the
+     * caller's payload, and naming a row that belongs to another project would
+     * copy that project's data into this project's audit trail. A model with no
+     * tenant column or no name column resolves nothing.
+     */
+    async findRelationNames(data) {
+        const names = new Map();
+        const ids = Array.from(new Set(data.ids.map((id) => {
+            return id.toLowerCase();
+        })));
+        if (ids.length === 0) {
+            return names;
+        }
+        const relatedModel = new data.modelType();
+        if (relatedModel instanceof User) {
+            for (const id of ids) {
+                const user = await this.getUserInfo(new ObjectID(id));
+                const name = (user === null || user === void 0 ? void 0 : user.name) || (user === null || user === void 0 ? void 0 : user.email) || null;
+                if (name) {
+                    names.set(id, name);
+                }
+            }
+            return names;
+        }
+        const tenantColumn = relatedModel.getTenantColumn();
+        if (!tenantColumn || !relatedModel.isTableColumn("name")) {
+            return names;
+        }
+        const rows = await this.getRelatedModelService(data.modelType).findBy({
+            query: {
+                _id: QueryHelper.any(ids.map((id) => {
+                    return new ObjectID(id);
+                })),
+                [tenantColumn]: data.projectId,
+            },
+            select: { _id: true, name: true },
+            skip: 0,
+            limit: ids.length,
+            props: { isRoot: true, ignoreHooks: true },
+        });
+        for (const row of rows) {
+            const name = this.toDisplayString(row["name"]);
+            if (row._id && name) {
+                names.set(row._id.toString().toLowerCase(), name);
+            }
+        }
+        return names;
+    }
+    /*
+     * A plain DatabaseService reads the related rows: the lookup needs no
+     * service hooks (it runs as root with hooks off), and going through a
+     * registry of concrete services would import every service into this one.
+     */
+    getRelatedModelService(modelType) {
+        let service = this.relatedModelServices.get(modelType);
+        if (!service) {
+            service = new DatabaseService(modelType);
+            this.relatedModelServices.set(modelType, service);
+        }
+        return service;
+    }
     getResourceType(model) {
         if (model.singularName) {
             return model.singularName;
@@ -398,18 +704,76 @@ export class AuditLogService extends AnalyticsDatabaseService {
             .name;
     }
     getResourceName(item) {
+        const itemRecord = item;
         for (const field of NAME_CANDIDATE_FIELDS) {
-            const columns = item.getTableColumns().columns;
-            if (!columns.includes(field)) {
+            if (!item.isTableColumn(field)) {
                 continue;
             }
-            const value = item[field];
-            if (typeof value === "string" && value.length > 0) {
-                return value;
+            const name = this.toDisplayString(itemRecord[field]);
+            if (name) {
+                return name;
             }
         }
         return null;
     }
+    /*
+     * The name a row has, or failing that the name of the row its
+     * resourceNameRelation points at - an SLO owner row is named after its user
+     * or team. Best effort: an entry is never lost for want of a name.
+     */
+    async resolveResourceName(data) {
+        var _a, _b;
+        const ownName = this.getResourceName(data.item);
+        if (ownName) {
+            return ownName;
+        }
+        const relation = (_a = data.model.enableAuditLogOn) === null || _a === void 0 ? void 0 : _a.resourceNameRelation;
+        if (!relation) {
+            return null;
+        }
+        const metadata = this.getRelationMetadata(data.model, relation);
+        if (!metadata ||
+            !metadata.modelType ||
+            metadata.type !== TableColumnType.Entity ||
+            !metadata.manyToOneRelationColumn) {
+            return null;
+        }
+        const relatedId = RelationValueUtil.getRelationId(data.item[metadata.manyToOneRelationColumn]);
+        if (!relatedId) {
+            return null;
+        }
+        try {
+            const names = await this.findRelationNames({
+                modelType: metadata.modelType,
+                ids: [relatedId],
+                projectId: data.projectId,
+            });
+            return (_b = names.get(relatedId.toLowerCase())) !== null && _b !== void 0 ? _b : null;
+        }
+        catch (err) {
+            logger.warn("AuditLog: could not resolve the resource name; recording the entry without one");
+            logger.warn(err);
+            return null;
+        }
+    }
+    /*
+     * A non-empty display string for a stored value: a string as it is, and a
+     * value object (Name, Email) through its own toString. Anything else - a
+     * plain object stringifying to "[object Object]" - is not a name.
+     */
+    toDisplayString(value) {
+        if (typeof value === "string") {
+            return value.trim().length > 0 ? value : null;
+        }
+        if (value instanceof ObjectID || value === null || value === undefined) {
+            return null;
+        }
+        if (typeof value === "object") {
+            const text = String(value);
+            return text.trim().length > 0 && text !== "[object Object]" ? text : null;
+        }
+        return null;
+    }
 }
 export default new AuditLogService();
 //# sourceMappingURL=AuditLogService.js.map