fix: clean up Pub/Sub Redis keys on deletion, refresh stale instances, and localize UI labels

- Delete oapp:pub:{id} set when removing a pubsub-type app to prevent Redis key leaks
- Replace running PubSubInstance on update() so config changes take effect without restart
- Reuse update() in start() to eliminate duplicated instance creation
- Wrap expiration labels in gt.gettext/ngettext for proper i18n pluralization
- Downgrade Pub/Sub start failure log from fatal to error (worker continues running)

Author: andris9

lib/oauth/pubsub/google.js

@@ -312,14 +312,15 @@ class GooglePubSub {
         // Backfill apps with baseScopes === 'pubsub' that are missing from the subscribers set
         let apps = await oauth2Apps.backfillPubSubApps();
         for (let app of apps) {
-            this.pubSubInstances.set(app, new PubSubInstance(this, { app }));
+            await this.update(app);
         }
     }
 
     async update(app) {
-        if (!this.pubSubInstances.has(app)) {
-            this.pubSubInstances.set(app, new PubSubInstance(this, { app }));
+        if (this.pubSubInstances.has(app)) {
+            await this.remove(app);
         }
+        this.pubSubInstances.set(app, new PubSubInstance(this, { app }));
     }
 
     async remove(app) {

lib/oauth2-apps.js

@@ -804,6 +804,10 @@ class OAuth2AppsHandler {
             pipeline = pipeline.srem(this.getPubsubAppKey(appData.pubSubApp), id);
         }
 
+        if (appData.baseScopes === 'pubsub') {
+            pipeline = pipeline.del(this.getPubsubAppKey(id));
+        }
+
         let deleteResult = await pipeline.exec();
 
         let hasError = (deleteResult[0] && deleteResult[0][0]) || (deleteResult[1] && deleteResult[1][0]);

lib/routes-ui.js

@@ -2646,20 +2646,21 @@ return true;`
             //   undefined - no data yet (app predates this feature or ensurePubsub hasn't run)
             //   null      - indefinite (no TTL set, ensurePubsub confirmed this)
             //   "Ns"      - TTL in seconds (e.g. "2678400s" for 31 days)
+            let gt = request.app.gt;
             for (let app of data.apps) {
                 if (!app.pubSubSubscription) {
                     app.expirationLabel = '';
                 } else if (!('subscriptionExpiration' in (app.meta || {}))) {
-                    app.expirationLabel = 'Unknown';
+                    app.expirationLabel = gt.gettext('Unknown');
                 } else if (app.meta.subscriptionExpiration === null) {
-                    app.expirationLabel = 'Indefinite';
+                    app.expirationLabel = gt.gettext('Indefinite');
                 } else {
                     let seconds = parseInt(app.meta.subscriptionExpiration, 10);
                     if (seconds && seconds > 0) {
                         let days = Math.round(seconds / 86400);
-                        app.expirationLabel = days === 1 ? '1 day' : `${days} days`;
+                        app.expirationLabel = util.format(gt.ngettext('%d day', '%d days', days), days);
                     } else {
-                        app.expirationLabel = 'Indefinite';
+                        app.expirationLabel = gt.gettext('Indefinite');
                     }
                 }
             }

test/pubsub-recovery-test.js

@@ -88,8 +88,8 @@ function createMockRedis() {
                     ops.push(() => 0);
                     return this;
                 },
-                del: function () {
-                    ops.push(() => 0);
+                del: function (key) {
+                    ops.push(() => redis.del(key));
                     return this;
                 },
                 expire: function () {
@@ -145,6 +145,18 @@ function createMockRedis() {
             }
             return removed;
         },
+        del: async key => {
+            let existed = 0;
+            if (mockSets[key]) {
+                delete mockSets[key];
+                existed = 1;
+            }
+            if (mockRedisData[key]) {
+                delete mockRedisData[key];
+                existed = 1;
+            }
+            return existed;
+        },
         exists: async () => 0,
         get: async () => null,
         set: async () => 'OK',
@@ -790,6 +802,23 @@ test('Pub/Sub subscription recovery tests', async t => {
             assert.strictEqual(instance.stopped, true, 'instance should be stopped');
             assert.strictEqual(pubsub.pubSubInstances.size, 0, 'instance should be removed from map');
         });
+
+        await t2.test('update() replaces existing instance with a fresh one', async () => {
+            let pubsub = new GooglePubSub({ call: async () => {} });
+            await pubsub.update('refresh-test');
+            let firstInstance = pubsub.pubSubInstances.get('refresh-test');
+            assert.ok(firstInstance, 'instance should exist after first update');
+
+            await pubsub.update('refresh-test');
+            let secondInstance = pubsub.pubSubInstances.get('refresh-test');
+            assert.ok(secondInstance, 'instance should exist after second update');
+            assert.notStrictEqual(firstInstance, secondInstance, 'instance should be a new object');
+            assert.strictEqual(firstInstance.stopped, true, 'old instance should be stopped');
+            assert.strictEqual(secondInstance.stopped, false, 'new instance should not be stopped');
+            assert.strictEqual(pubsub.pubSubInstances.size, 1, 'map should still have exactly one entry');
+
+            pubsub.stopAll();
+        });
     });
 
     // --- _recoveryBackoffMs() tests ---
@@ -852,6 +881,24 @@ test('Pub/Sub subscription recovery tests', async t => {
             })();
         });
 
+        await t2.test('del() deletes oapp:pub:{id} set when app has baseScopes pubsub', async () => {
+            let appId = 'del-pubsub-provider';
+            let pubsubAppKey = `${REDIS_PREFIX}oapp:pub:${appId}`;
+            let appFields = { id: appId, baseScopes: 'pubsub', provider: 'gmailService' };
+
+            mockSets[indexKey] = new Set([appId]);
+            mockSets[subscribersKey] = new Set([appId]);
+            mockSets[pubsubAppKey] = new Set(['subscriber-1', 'subscriber-2']);
+            mockRedisData[dataKey] = { [`${appId}:data`]: msgpack.encode(appFields) };
+
+            await withMockedOauth2Apps({ get: async () => ({ ...appFields }) }, async () => {
+                let result = await oauth2Apps.del(appId);
+                assert.strictEqual(result.id, appId, 'should return correct id');
+                assert.ok(!mockSets[subscribersKey] || !mockSets[subscribersKey].has(appId), 'app should be removed from subscriber set');
+                assert.ok(!mockSets[pubsubAppKey], 'oapp:pub:{id} set should be deleted');
+            })();
+        });
+
         await t2.test('del() without pubSubApp skips pubsub app set removal', async () => {
             let appId = 'del-no-pubsub-app';
             let appFields = { id: appId, baseScopes: 'api', provider: 'gmail' };

workers/webhooks.js

@@ -620,7 +620,7 @@ googlePubSub
         logger.info({ msg: 'Started processing Google pub/sub' });
     })
     .catch(err => {
-        logger.fatal({ msg: 'Failed to start processing Google pub/sub', err });
+        logger.error({ msg: 'Failed to start processing Google pub/sub', err });
     });
 
 logger.info({ msg: 'Started Webhooks worker thread', version: packageData.version });