Feat 83 recording (socket profiler recording & replay)

.gitignore

@@ -14,6 +14,7 @@ backend/sessions
 backend/node_modules
 backend/logs
 backend/coverage
+logs/
 
 # ignore build files
 dist/
@@ -49,4 +50,5 @@ utils/rpcs/moodleAPI/moodle_api/__pycache__
 *.pyc 
 email-mappings.py
 gitleaks-clean.sh
-.mailmap
+.mailmap
+.DS_Store

backend/db/migrations/20260412231117-create-recording.js

@@ -0,0 +1,83 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('recording', {
+      id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      name: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      status: {
+        type: Sequelize.STRING,
+        allowNull: false,
+        defaultValue: 'recording',
+      },
+      startTime: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      endTime: {
+        type: Sequelize.DATE,
+        allowNull: true,
+        defaultValue: null,
+      },
+      // Recordings are soft-deleted only, so a user delete must never cascade
+      // them away. RESTRICT forces whoever adds user deletion to soft-delete
+      // the recordings first rather than silently destroying recorded data.
+      userId: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        references: {
+          model: 'user',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      participantSocketIds: {
+        type: Sequelize.JSONB,
+        allowNull: true,
+        defaultValue: null,
+      },
+      excludeEvents: {
+        type: Sequelize.JSONB,
+        allowNull: true,
+        defaultValue: null,
+      },
+      deleted: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      deletedAt: {
+        type: Sequelize.DATE,
+        allowNull: true,
+        defaultValue: null,
+      },
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn('NOW'),
+      },
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn('NOW'),
+      },
+    });
+    // publicTable is false, so getAutoTable filters these rows by userId.
+    await queryInterface.addIndex('recording', ['userId'], {
+      name: 'recording_userId_idx',
+    });
+  },
+
+  async down(queryInterface, Sequelize) {
+    await queryInterface.dropTable('recording');
+  },
+};

backend/db/migrations/20260412231119-create-trace.js

@@ -0,0 +1,96 @@
+'use strict';
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable('trace', {
+      id: {
+        type: Sequelize.INTEGER,
+        primaryKey: true,
+        autoIncrement: true,
+        allowNull: false,
+      },
+      recordingId: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        references: {
+          model: 'recording',
+          key: 'id',
+        },
+        onDelete: 'CASCADE',
+        onUpdate: 'CASCADE',
+      },
+      // SET NULL would leave the recording intact but silently unreplayable
+      // (groupTracesBySocket skips traces with no userId). RESTRICT keeps trace
+      // ownership honest; recordings are soft-deleted, never orphaned.
+      userId: {
+        type: Sequelize.INTEGER,
+        allowNull: true,
+        references: {
+          model: 'user',
+          key: 'id',
+        },
+        onDelete: 'RESTRICT',
+        onUpdate: 'CASCADE',
+      },
+      socketId: {
+        type: Sequelize.STRING,
+        allowNull: true,
+      },
+      action: {
+        type: Sequelize.STRING,
+        allowNull: false,
+      },
+      payload: {
+        type: Sequelize.JSONB,
+        allowNull: true,
+      },
+      // true = frontend -> backend (onAny), false = backend -> frontend (onAnyOutgoing)
+      direction: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+      },
+      startTime: {
+        type: Sequelize.DATE,
+        allowNull: false,
+      },
+      endTime: {
+        type: Sequelize.DATE,
+        allowNull: true,
+      },
+      deleted: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+      },
+      deletedAt: {
+        type: Sequelize.DATE,
+        allowNull: true,
+        defaultValue: null,
+      },
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn('NOW'),
+      },
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn('NOW'),
+      },
+    });
+
+    // Every trace lookup filters by recordingId (getTraces, buildSessionPool,
+    // stopRecording), so that's the index that matters.
+    await queryInterface.addIndex('trace', ['recordingId'], {
+      name: 'trace_recordingId_idx',
+    });
+
+    await queryInterface.addIndex('trace', ['socketId'], {
+      name: 'trace_socketId_idx',
+    });
+  },
+
+  async down(queryInterface, Sequelize) {
+    await queryInterface.dropTable('trace');
+  },
+};

backend/db/migrations/20260506220447-extend-nav-socket-profiler.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const navElements = [
+  {
+    name: "Socket Profiler",
+    groupId: "Manage",
+    icon: "record-circle",
+    order: 16,
+    admin: true,
+    path: "Socket_Profiler",
+    component: "SocketProfiler",
+  }
+];
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.bulkInsert(
+      "nav_element",
+      await Promise.all(
+        navElements.map(async (t) => {
+          const groupId = await queryInterface.rawSelect(
+            "nav_group",
+            {
+              where: { name: t.groupId },
+            },
+            ["id"]
+          );
+
+          t["createdAt"] = new Date();
+          t["updatedAt"] = new Date();
+          t["groupId"] = groupId;
+
+          return t;
+        }),
+        {}
+      )
+    );
+  },
+
+  async down(queryInterface, Sequelize) {
+    await queryInterface.bulkDelete(
+      "nav_element",
+      {
+        name: navElements.map((t) => t.name),
+      },
+      {}
+    );
+  },
+};

backend/db/models/recording.js

@@ -0,0 +1,65 @@
+"use strict";
+const MetaModel = require("../MetaModel.js");
+
+module.exports = (sequelize, DataTypes) => {
+    // Allowed recording lifecycle states. Single source of truth for the
+    // status validator below; add new states here rather than scattering
+    // string literals. "interrupted" is set on startup for recordings whose
+    // server died mid-capture.
+    const RECORDING_STATUSES = ["recording", "finished", "disconnected", "interrupted"];
+
+    class Recording extends MetaModel {
+        // MetaModel flags. autoTable registers this model for generic CRUD
+        // over sockets. fields=[] means no column whitelist (all columns
+        // returned). publicTable=false keeps recordings out of unauthenticated
+        // reads: they are admin-only artifacts, and the rows expose who was
+        // recorded, their session ids and their activity times.
+        static autoTable = true;
+        static fields = [];
+        static publicTable = false;
+
+        static associate(models) {
+            Recording.belongsTo(models["user"], {
+                foreignKey: "userId",
+                as: "user",
+            });
+            Recording.hasMany(models["trace"], {
+                foreignKey: "recordingId",
+                as: "traces",
+            });
+        }
+    }
+
+    Recording.init(
+        {
+            name: DataTypes.STRING,
+            status: {
+                type: DataTypes.STRING,
+                allowNull: false,
+                validate: { isIn: [RECORDING_STATUSES] },
+            },
+            startTime: {
+                type: DataTypes.DATE,
+                allowNull: false,
+            },
+            endTime: DataTypes.DATE,
+            userId: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            participantSocketIds: DataTypes.JSONB,
+            excludeEvents: DataTypes.JSONB,
+            deleted: DataTypes.BOOLEAN,
+            deletedAt: DataTypes.DATE,
+            createdAt: DataTypes.DATE,
+            updatedAt: DataTypes.DATE,
+        },
+        {
+            sequelize,
+            modelName: "recording",
+            tableName: "recording",
+        }
+    );
+
+    return Recording;
+};

backend/db/models/trace.js

@@ -0,0 +1,61 @@
+"use strict";
+const MetaModel = require("../MetaModel.js");
+
+module.exports = (sequelize, DataTypes) => {
+    class Trace extends MetaModel {
+        // MetaModel flags. autoTable registers this model for generic CRUD
+        // over sockets. fields=[] means no column whitelist. publicTable=false
+        // keeps traces out of the generic subscription layer, since payloads
+        // can hold sensitive event data — they're fetched explicitly instead.
+        static autoTable = true;
+        static fields = [];
+        static publicTable = false;
+
+        static associate(models) {
+            Trace.belongsTo(models["recording"], {
+                foreignKey: "recordingId",
+                as: "recording",
+            });
+            Trace.belongsTo(models["user"], {
+                foreignKey: "userId",
+                as: "user",
+            });
+        }
+    }
+
+    Trace.init(
+        {
+            recordingId: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            userId: DataTypes.INTEGER,
+            socketId: DataTypes.STRING,
+            action: {
+                type: DataTypes.STRING,
+                allowNull: false,
+            },
+            payload: DataTypes.JSONB,
+            direction: {
+                type: DataTypes.BOOLEAN, // true = frontend -> backend, false = backend -> frontend
+                allowNull: false,
+            },
+            startTime: {
+                type: DataTypes.DATE,
+                allowNull: false,
+            },
+            endTime: DataTypes.DATE,
+            deleted: DataTypes.BOOLEAN,
+            deletedAt: DataTypes.DATE,
+            createdAt: DataTypes.DATE,
+            updatedAt: DataTypes.DATE,
+        },
+        {
+            sequelize,
+            modelName: "trace",
+            tableName: "trace",
+        }
+    );
+
+    return Trace;
+};