feat: implement logging interceptor for telemetry data collection; add TelemetryLog model and service

Author: NarwhalChen

backend/src/app.module.ts

@@ -21,7 +21,7 @@ import { GitHubModule } from './github/github.module';
 import { AppConfigService } from './config/config.service';
 import { getDatabaseConfig } from './database.config';
 import { DashboardModule } from './dashboard/dashboard.module';
-import { Role } from './auth/role/role.model';
+import { InterceptorModule } from './interceptor/interceptor.module';
 
 @Module({
   imports: [
@@ -59,6 +59,7 @@ import { Role } from './auth/role/role.model';
     TypeOrmModule.forFeature([User]),
     GitHubModule,
     DashboardModule,
+    InterceptorModule,
   ],
   providers: [
     AppResolver,

backend/src/interceptor/LoggingInterceptor.ts

@@ -7,11 +7,16 @@ import {
   ContextType,
 } from '@nestjs/common';
 import { Observable } from 'rxjs';
+import { tap } from 'rxjs/operators';
 import { GqlExecutionContext } from '@nestjs/graphql';
+import { TelemetryLogService } from './telemetry-log.service';
 
 @Injectable()
 export class LoggingInterceptor implements NestInterceptor {
   private readonly logger = new Logger('RequestLogger');
+  private startTime: number;
+
+  constructor(private telemetryLogService: TelemetryLogService) {}
 
   intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
     const contextType = context.getType();
@@ -42,6 +47,9 @@ export class LoggingInterceptor implements NestInterceptor {
 
     const { operation, fieldName } = info;
     let variables = '';
+    const startTime = Date.now();
+    const request = ctx.getContext().req;
+    const userId = request?.user?.id;
 
     try {
       variables = JSON.stringify(ctx.getContext()?.req?.body?.variables ?? {});
@@ -50,12 +58,28 @@ export class LoggingInterceptor implements NestInterceptor {
     }
 
     this.logger.log(
-      `[GraphQL] ${operation.operation.toUpperCase()} \x1B[33m${fieldName}\x1B[39m${
+      `[GraphQL] ${operation.operation.toUpperCase()} [33m${fieldName}[39m${
         variables ? ` Variables: ${variables}` : ''
       }`,
     );
 
-    return next.handle();
+    return next.handle().pipe(
+      tap({
+        next: (value) => {
+          const timeConsumed = Date.now() - startTime;
+          this.telemetryLogService.create({
+            timestamp: new Date(),
+            requestMethod: operation.operation.toUpperCase(),
+            endpoint: fieldName,
+            input: variables,
+            output: JSON.stringify(value),
+            timeConsumed,
+            userId,
+            handler: 'GraphQL',
+          });
+        },
+      }),
+    );
   }
 
   private handleRestRequest(
@@ -64,13 +88,30 @@ export class LoggingInterceptor implements NestInterceptor {
   ): Observable<any> {
     const httpContext = context.switchToHttp();
     const request = httpContext.getRequest();
+    const startTime = Date.now();
 
-    const { method, url, body } = request;
+    const { method, url, body, user } = request;
 
     this.logger.log(
       `[REST] ${method.toUpperCase()} ${url} Body: ${JSON.stringify(body)}`,
     );
 
-    return next.handle();
+    return next.handle().pipe(
+      tap({
+        next: (value) => {
+          const timeConsumed = Date.now() - startTime;
+          this.telemetryLogService.create({
+            timestamp: new Date(),
+            requestMethod: method,
+            endpoint: url,
+            input: JSON.stringify(body),
+            output: JSON.stringify(value),
+            timeConsumed,
+            userId: user?.id,
+            handler: 'REST',
+          });
+        },
+      }),
+    );
   }
 }

backend/src/interceptor/interceptor.module.ts

@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { TelemetryLog } from './telemetry-log.model';
+import { TelemetryLogService } from './telemetry-log.service';
+import { LoggingInterceptor } from './LoggingInterceptor';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([TelemetryLog])],
+  providers: [TelemetryLogService, LoggingInterceptor],
+  exports: [TelemetryLogService, LoggingInterceptor],
+})
+export class InterceptorModule {}

backend/src/interceptor/telemetry-log.model.ts

@@ -0,0 +1,50 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity()
+@ObjectType()
+export class TelemetryLog {
+  @PrimaryGeneratedColumn()
+  @Field(() => ID)
+  id: number;
+
+  @Column({ type: 'datetime', default: () => 'CURRENT_TIMESTAMP' })
+  @Field(() => Date)
+  timestamp: Date;
+
+  @Column()
+  @Field()
+  requestMethod: string;
+
+  @Column('text')
+  @Field()
+  endpoint: string;
+
+  @Column('text', { nullable: true })
+  @Field({ nullable: true })
+  input: string;
+
+  @Column('text', { nullable: true })
+  @Field({ nullable: true })
+  output: string;
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  inputToken: string;
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  outputToken: string;
+
+  @Column('int')
+  @Field()
+  timeConsumed: number;
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  userId: string;
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  handler: string;
+}

backend/src/interceptor/telemetry-log.service.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { TelemetryLog } from './telemetry-log.model';
+
+@Injectable()
+export class TelemetryLogService {
+  constructor(
+    @InjectRepository(TelemetryLog)
+    private telemetryLogRepository: Repository<TelemetryLog>,
+  ) {}
+
+  async create(data: Partial<TelemetryLog>): Promise<TelemetryLog> {
+    const telemetryLog = this.telemetryLogRepository.create(data);
+    return await this.telemetryLogRepository.save(telemetryLog);
+  }
+
+  async findAll(): Promise<TelemetryLog[]> {
+    return await this.telemetryLogRepository.find({
+      order: { timestamp: 'DESC' },
+      take: 100,
+    });
+  }
+
+  async findById(id: number): Promise<TelemetryLog> {
+    return await this.telemetryLogRepository.findOne({ where: { id } });
+  }
+}