Fix error field name in logger calls across codebase

Rename `error` to `err` in all logger calls so Pino's error serializer
properly extracts message and stack trace in structured logs.

Author: cmraible

src/services/batch-worker/BatchWorker.ts

@@ -105,12 +105,12 @@ class BatchWorker {
             if (this.batch.length >= this.batchSize) {
                 await this.flushBatch();
             }
-        } catch (error) {
+        } catch (err) {
             logger.error({
                 event: 'WorkerMessageProcessingFailed',
                 messageId: message.id,
                 messageData: this.getMessageData(message),
-                err: error
+                err
             });
             message.nack();
         }
@@ -121,12 +121,12 @@ class BatchWorker {
             const messageData = message.data.toString();
             const parsedMessageData = JSON.parse(messageData);
             return Value.Parse(PageHitRawSchema, parsedMessageData);
-        } catch (error) {
+        } catch (err) {
             logger.error({
                 event: 'WorkerMessageParsingFailed',
                 messageId: message.id,
                 messageData: this.getMessageData(message),
-                err: error
+                err
             });
             // Ack the message. If we failed to parse it, we won't succeed next time.
             message.ack();
@@ -160,20 +160,20 @@ class BatchWorker {
                 batchSize: batchToFlush.length,
                 messageIds: batchToFlush.map(item => item.message.id)
             });
-        } catch (error) {
+        } catch (err) {
             logger.error({
                 event: 'WorkerBatchFlushFailed',
                 batchSize: batchToFlush.length,
                 messageIds: batchToFlush.map(item => item.message.id),
-                err: error
+                err
             });
 
             // Nack all messages in the failed batch
             batchToFlush.forEach((item) => {
                 item.message.nack();
             });
 
-            throw error;
+            throw err;
         }
     }
 
@@ -187,12 +187,12 @@ class BatchWorker {
 
             try {
                 await this.flushBatch();
-            } catch (error) {
+            } catch (err) {
                 logger.error({
                     event: 'WorkerScheduledFlushFailed',
                     batchSize: this.batch.length,
                     messageIds: this.batch.map(item => item.message.id),
-                    err: error
+                    err
                 });
             }
 

src/services/events/publisher.ts

@@ -41,15 +41,14 @@ class EventPublisher {
             });
 
             return messageId;
-        } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+        } catch (err) {
             logger.error({
                 event: 'EventPublishFailed',
-                error: errorMessage,
+                err,
                 topic,
                 payload
             });
-            throw error;
+            throw err;
         }
     }
 }

src/services/salt-store/FileSaltStore.ts

@@ -55,8 +55,8 @@ export class FileSaltStore implements ISaltStore {
                 // File doesn't exist, create it with empty object
                 await this.writeFile({});
             }
-        } catch (error) {
-            logger.warn({event: 'FileSaltStoreInitializationFailed', error});
+        } catch (err) {
+            logger.warn({event: 'FileSaltStoreInitializationFailed', err});
         }
     }
 
@@ -80,12 +80,12 @@ export class FileSaltStore implements ISaltStore {
                 }
             }
             return records;
-        } catch (error) {
-            if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        } catch (err) {
+            if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
                 return {};
             }
             // Handle corrupted file
-            logger.error({event: 'FileSaltStoreReadFailed', error});
+            logger.error({event: 'FileSaltStoreReadFailed', err});
             await this.writeFile({});
             return {};
         }
@@ -247,9 +247,9 @@ export class FileSaltStore implements ISaltStore {
                 }
 
                 return deletedCount;
-            } catch (error) {
-                logger.error({event: 'FileSaltStoreCleanupFailed', error});
-                throw error;
+            } catch (err) {
+                logger.error({event: 'FileSaltStoreCleanupFailed', err});
+                throw err;
             }
         });
     }

src/services/salt-store/FirestoreSaltStore.ts

@@ -75,9 +75,9 @@ export class FirestoreSaltStore implements ISaltStore {
         try {
             // Simple operation to test connectivity - just get the collection reference
             await this.firestore.collection(this.collectionName).limit(1).get();
-        } catch (error) {
+        } catch (err) {
             // Log warning but don't throw - allow graceful degradation
-            logger.warn({event: 'FirestoreSaltStoreHealthCheckFailed', error});
+            logger.warn({event: 'FirestoreSaltStoreHealthCheckFailed', err});
         }
     }
 
@@ -280,17 +280,17 @@ export class FirestoreSaltStore implements ISaltStore {
                     batchSize
                 });
             }
-        } catch (error) {
+        } catch (err) {
             logger.error({
                 event: 'FirestoreSaltStoreCleanupFailed',
-                error,
+                err,
                 deletedCount: totalDeleted,
                 totalToBeDeleted,
                 durationMs: Date.now() - startTime,
                 cutoffDate: cutoffDate.toISOString(),
                 batchSize
             });
-            throw error;
+            throw err;
         }
 
         logger.info({
@@ -327,21 +327,21 @@ export class FirestoreSaltStore implements ISaltStore {
         try {
             // Use existing set method which handles atomic creation
             return await this.set(key, newSalt);
-        } catch (error) {
+        } catch (err) {
             // Handle race condition: another process created the document between our read and create
             // We could do this with a transaction, but it adds unnecessary performance overhead
-            if (error instanceof SaltAlreadyExistsError) {
+            if (err instanceof SaltAlreadyExistsError) {
                 // Another process created it, read and return the existing document
                 const freshSalt = await this.get(key);
                 if (!freshSalt) {
                     throw new Error(`Document should exist but was not found after race condition for key: ${key}`);
                 }
                 return freshSalt;
             }
-            
+
             // Re-throw other errors
-            logger.error({event: 'FirestoreSaltStoreGetOrCreateFailed', error});
-            throw error;
+            logger.error({event: 'FirestoreSaltStoreGetOrCreateFailed', err});
+            throw err;
         }
     }
 }

src/services/user-signature/UserSignatureService.ts

@@ -38,8 +38,8 @@ export class UserSignatureService {
             try {
                 const deletedCount = await this.saltStore.cleanup();
                 logger.info({event: 'SaltCleanupCompleted', deletedCount});
-            } catch (error) {
-                logger.error({event: 'SaltCleanupFailed', error});
+            } catch (err) {
+                logger.error({event: 'SaltCleanupFailed', err});
             }
         };
 

test/unit/services/user-signature/UserSignatureService.test.ts

@@ -309,7 +309,7 @@ describe('UserSignatureService', () => {
                 await timeoutCallback();
 
                 expect(cleanupSpy).toHaveBeenCalledOnce();
-                expect(loggerErrorSpy).toHaveBeenCalledWith({event: 'SaltCleanupFailed', error});
+                expect(loggerErrorSpy).toHaveBeenCalledWith({event: 'SaltCleanupFailed', err: error});
 
                 service.stopCleanupScheduler();
             });