refactor: inject logging service

Author: joshunrau

apps/api/src/ability/ability.factory.ts

@@ -1,17 +1,18 @@
 import { AbilityBuilder, detectSubjectType } from '@casl/ability';
 import { createPrismaAbility } from '@casl/prisma';
-import { Injectable, Logger } from '@nestjs/common';
+import { LoggingService } from '@douglasneuroinformatics/libnest/logging';
+import { Injectable } from '@nestjs/common';
 import type { AppSubjectName } from '@opendatacapture/schemas/core';
 import { type UserModel } from '@prisma/generated-client';
 
 import type { AppAbility } from '@/core/types';
 
 @Injectable()
 export class AbilityFactory {
-  private readonly logger = new Logger(AbilityFactory.name);
+  constructor(private readonly loggingService: LoggingService) {}
 
   createForUser(user: UserModel): AppAbility {
-    this.logger.verbose('Creating ability for user: ' + user.username);
+    this.loggingService.verbose('Creating ability for user: ' + user.username);
     const ability = new AbilityBuilder<AppAbility>(createPrismaAbility);
     switch (user.basePermissionLevel) {
       case 'ADMIN':

apps/api/src/auth/guards/authentication.guard.ts

@@ -1,4 +1,5 @@
-import { type ExecutionContext, Injectable, Logger } from '@nestjs/common';
+import { LoggingService } from '@douglasneuroinformatics/libnest/logging';
+import { type ExecutionContext, Injectable } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import { AuthGuard } from '@nestjs/passport';
 import { type Request } from 'express';
@@ -9,14 +10,15 @@ import { type RouteAccessType } from '@/core/decorators/route-access.decorator';
 /** Allows request to proceed if the route is public or the user provides a valid JWT */
 @Injectable()
 export class AuthenticationGuard extends AuthGuard('jwt') {
-  private readonly logger = new Logger(AuthenticationGuard.name);
-
-  constructor(private readonly reflector: Reflector) {
+  constructor(
+    private readonly loggingService: LoggingService,
+    private readonly reflector: Reflector
+  ) {
     super();
   }
 
   override canActivate(context: ExecutionContext): boolean | Observable<boolean> | Promise<boolean> {
-    this.logger.verbose(`Request URL: ${context.switchToHttp().getRequest<Request>().url}`);
+    this.loggingService.verbose(`Request URL: ${context.switchToHttp().getRequest<Request>().url}`);
     return this.isPublicRoute(context) || super.canActivate(context);
   }
 
@@ -26,7 +28,7 @@ export class AuthenticationGuard extends AuthGuard('jwt') {
       context.getClass()
     ]);
     const result = routeAccess === 'public';
-    this.logger.verbose(`Public Route: ${result}`);
+    this.loggingService.verbose(`Public Route: ${result}`);
     return result;
   }
 }

apps/api/src/auth/guards/authorization.guard.ts

@@ -1,4 +1,5 @@
-import { Injectable, Logger } from '@nestjs/common';
+import { LoggingService } from '@douglasneuroinformatics/libnest/logging';
+import { Injectable } from '@nestjs/common';
 import type { CanActivate, ExecutionContext } from '@nestjs/common';
 import { Reflector } from '@nestjs/core';
 import type { Request } from 'express';
@@ -8,13 +9,14 @@ import type { RouteAccessType } from '@/core/decorators/route-access.decorator';
 
 @Injectable()
 export class AuthorizationGuard implements CanActivate {
-  private readonly logger = new Logger(AuthorizationGuard.name);
-
-  constructor(private readonly reflector: Reflector) {}
+  constructor(
+    private readonly loggingService: LoggingService,
+    private readonly reflector: Reflector
+  ) {}
 
   canActivate(context: ExecutionContext): boolean | Observable<boolean> | Promise<boolean> {
     const request = context.switchToHttp().getRequest<Request>();
-    this.logger.verbose(`Request URL: ${request.url}`);
+    this.loggingService.verbose(`Request URL: ${request.url}`);
 
     const routeAccess = this.reflector.getAllAndOverride<RouteAccessType | undefined>('RouteAccess', [
       context.getHandler(),

apps/api/src/auth/strategies/jwt.strategy.ts

@@ -1,4 +1,5 @@
-import { Injectable, Logger, NotFoundException, UnauthorizedException } from '@nestjs/common';
+import { LoggingService } from '@douglasneuroinformatics/libnest/logging';
+import { Injectable, NotFoundException, UnauthorizedException } from '@nestjs/common';
 import { PassportStrategy } from '@nestjs/passport';
 import type { JwtPayload } from '@opendatacapture/schemas/auth';
 import type { GroupModel, UserModel } from '@prisma/generated-client';
@@ -11,11 +12,10 @@ import { UsersService } from '@/users/users.service';
 
 @Injectable()
 export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
-  private readonly logger = new Logger(JwtStrategy.name);
-
   constructor(
     config: ConfigurationService,
     private readonly abilityFactory: AbilityFactory,
+    private readonly loggingService: LoggingService,
     private readonly usersService: UsersService
   ) {
     super({
@@ -29,7 +29,7 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
   async validate({ username }: JwtPayload): Promise<Request['user']> {
     const user = await this.getUser(username);
     const ability = this.abilityFactory.createForUser(user);
-    this.logger.verbose(`Validated Token for User: ${username}`);
+    this.loggingService.verbose(`Validated Token for User: ${username}`);
     return { ...user, ability };
   }
 

apps/api/src/demo/demo.service.ts

@@ -1,7 +1,8 @@
 import { randomValue } from '@douglasneuroinformatics/libjs';
 import { toUpperCase } from '@douglasneuroinformatics/libjs';
+import { LoggingService } from '@douglasneuroinformatics/libnest/logging';
 import { faker } from '@faker-js/faker';
-import { Injectable, Logger } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { DEMO_GROUPS, DEMO_USERS } from '@opendatacapture/demo';
 import enhancedDemographicsQuestionnaire from '@opendatacapture/instrument-library/forms/enhanced-demographics-questionnaire.js';
 import generalConsentForm from '@opendatacapture/instrument-library/forms/general-consent-form.js';
@@ -33,12 +34,11 @@ faker.seed(123);
 
 @Injectable()
 export class DemoService {
-  private readonly logger = new Logger(DemoService.name);
-
   constructor(
     private readonly groupsService: GroupsService,
     private readonly instrumentRecordsService: InstrumentRecordsService,
     private readonly instrumentsService: InstrumentsService,
+    private readonly loggingService: LoggingService,
     private readonly prismaService: PrismaService,
     private readonly sessionsService: SessionsService,
     private readonly subjectsService: SubjectsService,
@@ -54,7 +54,7 @@ export class DemoService {
   }): Promise<void> {
     try {
       const dbName = await this.prismaService.getDbName();
-      this.logger.log(`Initializing demo for database: '${dbName}'`);
+      this.loggingService.log(`Initializing demo for database: '${dbName}'`);
 
       const hq = (await this.instrumentsService.create({ bundle: happinessQuestionnaire })) as WithID<
         FormInstrument<HappinessQuestionnaireData, Language[]>
@@ -66,33 +66,33 @@ export class DemoService {
         this.instrumentsService.create({ bundle: patientHealthQuestionnaire9 })
       ]);
 
-      this.logger.debug('Done creating forms');
+      this.loggingService.debug('Done creating forms');
 
       await this.instrumentsService.create({ bundle: breakoutTask });
-      this.logger.debug('Done creating interactive instruments');
+      this.loggingService.debug('Done creating interactive instruments');
 
       await this.instrumentsService.create({ bundle: happinessQuestionnaireWithConsent });
-      this.logger.debug('Done creating series instruments');
+      this.loggingService.debug('Done creating series instruments');
 
       const groups: (Group & { dummyIdPrefix?: string })[] = [];
       for (const group of DEMO_GROUPS) {
         const { dummyIdPrefix, ...createGroupData } = group;
         const groupModel = await this.groupsService.create(createGroupData);
         groups.push({ ...groupModel, dummyIdPrefix });
       }
-      this.logger.debug('Done creating groups');
+      this.loggingService.debug('Done creating groups');
 
       for (const user of DEMO_USERS) {
         await this.usersService.create({
           ...user,
           groupIds: user.groupNames.map((name) => groups.find((group) => group.name === name)!.id)
         });
       }
-      this.logger.debug('Done creating users');
+      this.loggingService.debug('Done creating users');
 
       let researchId = 1;
       for (let i = 0; i < dummySubjectCount; i++) {
-        this.logger.debug(`Creating dummy subject ${i + 1}/${dummySubjectCount}`);
+        this.loggingService.debug(`Creating dummy subject ${i + 1}/${dummySubjectCount}`);
         const group = randomValue(groups)!;
         const subjectIdData = {
           dateOfBirth: faker.date.birthdate(),
@@ -141,12 +141,12 @@ export class DemoService {
             subjectId: subject.id
           });
         }
-        this.logger.debug(`Done creating dummy subject ${i + 1}`);
+        this.loggingService.debug(`Done creating dummy subject ${i + 1}`);
       }
     } catch (err) {
       if (err instanceof Error) {
-        this.logger.error(err.cause);
-        this.logger.error(err);
+        this.loggingService.error(err.cause);
+        this.loggingService.error(err);
       }
       throw err;
     }

apps/api/src/gateway/gateway.service.ts

@@ -1,6 +1,7 @@
 import { HybridCrypto } from '@douglasneuroinformatics/libcrypto';
+import { LoggingService } from '@douglasneuroinformatics/libnest/logging';
 import { HttpService } from '@nestjs/axios';
-import { BadGatewayException, HttpStatus, Injectable, Logger } from '@nestjs/common';
+import { BadGatewayException, HttpStatus, Injectable } from '@nestjs/common';
 import { $MutateAssignmentResponseBody, $RemoteAssignment } from '@opendatacapture/schemas/assignment';
 import type {
   Assignment,
@@ -18,11 +19,10 @@ import { InstrumentsService } from '@/instruments/instruments.service';
 
 @Injectable()
 export class GatewayService {
-  private readonly logger = new Logger(GatewayService.name);
-
   constructor(
     private readonly httpService: HttpService,
-    private readonly instrumentsService: InstrumentsService
+    private readonly instrumentsService: InstrumentsService,
+    private readonly loggingService: LoggingService
   ) {}
 
   async createRemoteAssignment(assignment: Assignment, publicKey: CryptoKey): Promise<MutateAssignmentResponseBody> {
@@ -63,7 +63,7 @@ export class GatewayService {
     }
     const result = await $RemoteAssignment.array().safeParseAsync(response.data);
     if (!result.success) {
-      this.logger.error({
+      this.loggingService.error({
         data: response.data as unknown,
         error: result.error.format(),
         message: 'ERROR: Remote assignments received from gateway do not match expected structure'
@@ -85,7 +85,7 @@ export class GatewayService {
     const result = await $GatewayHealthcheckSuccessResult.safeParseAsync(response.data);
     if (!result.success) {
       const statusText = 'Healthcheck data received from gateway do not match expected structure';
-      this.logger.error({
+      this.loggingService.error({
         data: response.data as unknown,
         error: result.error.format(),
         message: `ERROR: ${statusText}`

apps/api/src/gateway/gateway.synchronizer.ts

@@ -1,5 +1,6 @@
 import { HybridCrypto } from '@douglasneuroinformatics/libcrypto';
-import { Injectable, InternalServerErrorException, Logger, type OnApplicationBootstrap } from '@nestjs/common';
+import { LoggingService } from '@douglasneuroinformatics/libnest/logging';
+import { Injectable, InternalServerErrorException, type OnApplicationBootstrap } from '@nestjs/common';
 import type { RemoteAssignment } from '@opendatacapture/schemas/assignment';
 import { $Json } from '@opendatacapture/schemas/core';
 
@@ -9,13 +10,11 @@ import { InstrumentRecordsService } from '@/instrument-records/instrument-record
 import { InstrumentsService } from '@/instruments/instruments.service';
 import { SessionsService } from '@/sessions/sessions.service';
 import { SetupService } from '@/setup/setup.service';
-import { VirtualizationService } from '@/virtualization/virtualization.service';
 
 import { GatewayService } from './gateway.service';
 
 @Injectable()
 export class GatewaySynchronizer implements OnApplicationBootstrap {
-  private readonly logger = new Logger(GatewaySynchronizer.name);
   private readonly refreshInterval: number;
 
   constructor(
@@ -24,9 +23,9 @@ export class GatewaySynchronizer implements OnApplicationBootstrap {
     private readonly gatewayService: GatewayService,
     private readonly instrumentsService: InstrumentsService,
     private readonly instrumentRecordsService: InstrumentRecordsService,
+    private readonly loggingService: LoggingService,
     private readonly sessionsService: SessionsService,
-    private readonly setupService: SetupService,
-    private readonly virtualizationService: VirtualizationService
+    private readonly setupService: SetupService
   ) {
     this.refreshInterval = configurationService.get('GATEWAY_REFRESH_INTERVAL');
   }
@@ -42,10 +41,10 @@ export class GatewaySynchronizer implements OnApplicationBootstrap {
     const assignment = await this.assignmentsService.findById(remoteAssignment.id);
 
     if (!remoteAssignment.completedAt) {
-      this.logger.error(`Field 'completedAt' is null for assignment '${assignment.id}'`);
+      this.loggingService.error(`Field 'completedAt' is null for assignment '${assignment.id}'`);
       return;
     } else if (!remoteAssignment.symmetricKey) {
-      this.logger.error(`Field 'symmetricKey' is null for assignment '${assignment.id}'`);
+      this.loggingService.error(`Field 'symmetricKey' is null for assignment '${assignment.id}'`);
       return;
     }
 
@@ -65,7 +64,7 @@ export class GatewaySynchronizer implements OnApplicationBootstrap {
 
     if (instrument.kind === 'SERIES') {
       if (!(remoteAssignment.encryptedData.startsWith('$') && remoteAssignment.symmetricKey.startsWith('$'))) {
-        this.logger.error({ remoteAssignment });
+        this.loggingService.error({ remoteAssignment });
         throw new InternalServerErrorException('Malformed remote assignment for series instrument');
       }
       cipherTexts.push(...remoteAssignment.encryptedData.slice(1).split('$'));
@@ -80,7 +79,7 @@ export class GatewaySynchronizer implements OnApplicationBootstrap {
         );
       }
     } else if (remoteAssignment.encryptedData.includes('$') || remoteAssignment.symmetricKey.includes('$')) {
-      this.logger.error({ remoteAssignment });
+      this.loggingService.error({ remoteAssignment });
       throw new InternalServerErrorException('Malformed remote assignment for scalar instrument');
     } else {
       cipherTexts.push(remoteAssignment.encryptedData);
@@ -113,12 +112,12 @@ export class GatewaySynchronizer implements OnApplicationBootstrap {
           sessionId: session.id,
           subjectId: assignment.subjectId
         });
-        this.logger.log(`Created record with ID: ${record.id}`);
+        this.loggingService.log(`Created record with ID: ${record.id}`);
         createdRecordIds.push(record.id);
       }
       await this.gatewayService.deleteRemoteAssignment(assignment.id);
     } catch (err) {
-      this.logger.error({
+      this.loggingService.error({
         data: {
           assignment,
           cipherTexts,
@@ -127,10 +126,10 @@ export class GatewaySynchronizer implements OnApplicationBootstrap {
         },
         message: 'Failed to Process Data'
       });
-      this.logger.error(err);
+      this.loggingService.error(err);
       for (const id of createdRecordIds) {
         await this.instrumentRecordsService.deleteById(id);
-        this.logger.log(`Deleted Record with ID: ${id}`);
+        this.loggingService.log(`Deleted Record with ID: ${id}`);
       }
       throw err;
     }
@@ -139,16 +138,19 @@ export class GatewaySynchronizer implements OnApplicationBootstrap {
   private async sync() {
     const setupState = await this.setupService.getState();
     if (!setupState.isSetup) {
-      this.logger.log('Will not attempt synchronizing with gateway: app is not setup');
+      this.loggingService.log('Will not attempt synchronizing with gateway: app is not setup');
       return;
     }
 
-    this.logger.log('Synchronizing with gateway...');
+    this.loggingService.log('Synchronizing with gateway...');
     let remoteAssignments: RemoteAssignment[];
     try {
       remoteAssignments = await this.gatewayService.fetchRemoteAssignments();
     } catch (err) {
-      this.logger.error('Failed to Fetch Remote Assignments', err);
+      this.loggingService.error({
+        cause: err,
+        error: 'Failed to Fetch Remote Assignments'
+      });
       return;
     }
 
@@ -164,6 +166,6 @@ export class GatewaySynchronizer implements OnApplicationBootstrap {
         status: assignment.status
       });
     }
-    this.logger.log('Done synchronizing with gateway');
+    this.loggingService.log('Done synchronizing with gateway');
   }
 }

apps/api/src/instrument-records/instrument-measures.service.ts

@@ -1,4 +1,5 @@
-import { Injectable, InternalServerErrorException, Logger } from '@nestjs/common';
+import { LoggingService } from '@douglasneuroinformatics/libnest/logging';
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
 import type {
   FormInstrument,
   InstrumentMeasure,
@@ -11,7 +12,7 @@ import { match } from 'ts-pattern';
 
 @Injectable()
 export class InstrumentMeasuresService {
-  private readonly logger = new Logger(InstrumentMeasuresService.name);
+  constructor(private readonly loggingService: LoggingService) {}
 
   computeMeasures(measures: InstrumentMeasures, data: FormInstrument.Data | Json | Prisma.JsonValue) {
     const computedMeasures: { [key: string]: InstrumentMeasureValue } = {};
@@ -28,7 +29,7 @@ export class InstrumentMeasuresService {
       })
       .with({ kind: 'const' }, (measure) => {
         if (!(data && typeof data === 'object')) {
-          this.logger.error({ data, message: 'Invalid Data' });
+          this.loggingService.error({ data, message: 'Invalid Data' });
           const label = typeof measure.label === 'string' ? measure.label : (measure.label?.en ?? measure.label?.fr)!;
           throw new InternalServerErrorException(`Failed to compute measure '${label}': data must be object'`);
         }