feat: add clientIP and path to log context.

registry/server/auth.ts

@@ -245,7 +245,7 @@ export default async (app: Express, settingsService: SettingsService, config: an
                     return res.end(`<pre>${info.message}</pre><br><a href="/">Go to main page</a>`);
                 }
 
-                getLogger().info(`User ${user.identifier} authenticated via OpenID`)
+                getLogger().info(`User ${user.identifier} authenticated via OpenID`);
                 req.logIn(user, function (err) {
                     if (err) {
                         return next(err);

registry/server/middleware/context.ts

@@ -1,4 +1,4 @@
-import { RequestHandler } from 'express';
+import { Request, RequestHandler } from 'express';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { v4 } from 'uuid';
 
@@ -10,6 +10,8 @@ export interface Store {
     reqId: string;
     domain: string;
     user?: User;
+    path: string;
+    clientIp?: string;
 }
 
 export const storage = new AsyncLocalStorage<TypedMap<Store>>();
@@ -20,6 +22,16 @@ export const contextMiddleware: RequestHandler = (req, res, next) => {
     storage.run(store, () => {
         store.set('reqId', getPluginManagerInstance().getReportingPlugin().genReqId?.() ?? v4());
         store.set('domain', req.hostname);
+        store.set('path', req.path);
+        store.set('clientIp', getUserIp(req));
         next();
     });
 };
+
+function getUserIp(req: Request) {
+    const forwarded = req.headers['x-forwarded-for'];
+    const headerValue = Array.isArray(forwarded)
+        ? forwarded[0] // If it's an array, take the first one
+        : forwarded;
+    return typeof headerValue === 'string' ? headerValue.split(',')[0] : req.socket.remoteAddress;
+}

registry/tests/context.spec.ts

@@ -0,0 +1,52 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import express from 'express';
+import request from 'supertest';
+import { contextMiddleware, storage } from '../server/middleware/context';
+
+function createTestAppWithContextMiddleware() {
+    // Create a new express application
+    const app = express();
+
+    // Add the contextMiddleware to the express application
+    app.use(contextMiddleware);
+
+    // Define a test route that will retrieve the values from the storage
+    app.get('/test', (req, res) => {
+        // Access the storage directly
+        const store = storage.getStore();
+        if (store) {
+            res.send({
+                reqId: store.get('reqId'),
+                domain: store.get('domain'),
+                path: store.get('path'),
+                clientIp: store.get('clientIp'),
+            });
+        } else {
+            res.status(500).send('No store found');
+        }
+    });
+    return app;
+}
+
+describe('contextMiddleware', () => {
+    it('should set the correct store values', (done) => {
+        const app = createTestAppWithContextMiddleware();
+
+        // Use supertest to simulate a request to the test route
+        request(app)
+            .get('/test?test=1')
+            .set('X-Forwarded-For', '10.10.10.1,12.13.14.15')
+            .expect(200)
+            .end((err, response) => {
+                if (err) return done(err);
+
+                const body = response.body;
+                expect(body.domain).to.equal('127.0.0.1');
+                expect(body.path).to.equal('/test');
+                expect(body.clientIp).to.equal('10.10.10.1');
+
+                done();
+            });
+    });
+});