Making logging optional

README.MD

@@ -59,7 +59,7 @@ import { LogLevel } from '@sentry/types';
       dsn: 'sentry_io_dsn',
       debug: true | false,
       environment: 'dev' | 'production' | 'some_environment',
-      release: 'some_release', | null, // must create a release in sentry.io dashboard
+      release: 'some_release' | null, // must create a release in sentry.io dashboard
       logLevel: LogLevel.Debug //based on sentry.io loglevel //
     }),
   ],
@@ -83,7 +83,7 @@ import { ConfigService } from '@ntegral/nestjs-config';
         dsn: cfg.get('SENTRY_DSN'),
         debug: true | false,
         environment: 'dev' | 'production' | 'some_environment',
-        release: 'some_release', | null, // must create a release in sentry.io dashboard
+        release: 'some_release' | null, // must create a release in sentry.io dashboard
         logLevel: LogLevel.Debug //based on sentry.io loglevel //
       }),
       inject: [ConfigService],
@@ -111,6 +111,76 @@ export class AppService {
 }
 ```
 
+## Logging
+
+You can provide a custom logger which implements `NestJS`'s `LoggerService` interface: 
+
+```typescript
+import { Module } from '@nestjs-common';
+import { SentryModule } from '@ntegral/nestjs-sentry';
+import { LogLevel } from '@sentry/types';
+
+@Module({
+  imports: [
+    SentryModule.forRoot({
+      dsn: 'sentry_io_dsn',
+      debug: true | false,
+      environment: 'dev' | 'production' | 'some_environment',
+      release: 'some_release' | null, // must create a release in sentry.io dashboard
+      logLevel: LogLevel.Debug, //based on sentry.io loglevel //
+      logger: new MyLogger(), // implements LoggerService
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Or completely disable logging:
+
+```typescript
+import { Module } from '@nestjs-common';
+import { SentryModule } from '@ntegral/nestjs-sentry';
+import { LogLevel } from '@sentry/types';
+
+@Module({
+  imports: [
+    SentryModule.forRoot({
+      dsn: 'sentry_io_dsn',
+      debug: true | false,
+      environment: 'dev' | 'production' | 'some_environment',
+      release: 'some_release' | null, // must create a release in sentry.io dashboard
+      logLevel: LogLevel.Debug, //based on sentry.io loglevel //
+      logger: null
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Or you can provide default logger (`ConsoleLogger`) options:
+
+```typescript
+import { Module } from '@nestjs-common';
+import { SentryModule } from '@ntegral/nestjs-sentry';
+import { LogLevel } from '@sentry/types';
+
+@Module({
+  imports: [
+    SentryModule.forRoot({
+      dsn: 'sentry_io_dsn',
+      debug: true | false,
+      environment: 'dev' | 'production' | 'some_environment',
+      release: 'some_release' | null, // must create a release in sentry.io dashboard
+      logLevel: LogLevel.Debug, //based on sentry.io loglevel //
+      loggerOptions: {
+        timestamp: true,
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
 ## Interceptors
 
 BREAKING CHANGES: The SentryInterceptor can be used in projects that don't require GraphQL. If you will be needed GraphQL support, use the GraphqlInterceptor.  Using the GraphqlInterceptor will create a dependancy for the @nestjs/graphql package.

lib/__tests__/sentry.module.spec.ts

@@ -5,15 +5,36 @@ import { SentryModuleOptions, SentryOptionsFactory } from '../sentry.interfaces'
 import { LogLevel } from '@sentry/types';
 import { SentryService } from '../sentry.service';
 import { SENTRY_TOKEN } from '../sentry.constants';
+import { ConsoleLogger } from '@nestjs/common';
+
+class CustomLogger extends ConsoleLogger {}
 
 describe('SentryModule', () => {
+    let logger = new CustomLogger('SentryModuleSpec');
+
     let config: SentryModuleOptions = {
         dsn: 'https://[email protected]/25956308132020',
         debug: true,
         environment: 'development',
         logLevel: LogLevel.Debug,
     }
 
+    let configWithCustomLogger: SentryModuleOptions = {
+        dsn: 'https://[email protected]/25956308132020',
+        debug: true,
+        environment: 'development',
+        logLevel: LogLevel.Debug,
+        logger,
+    }
+
+    let configWithNoLogger: SentryModuleOptions = {
+        dsn: 'https://[email protected]/25956308132020',
+        debug: true,
+        environment: 'development',
+        logLevel: LogLevel.Debug,
+        logger: null,
+    }
+
     class TestService implements SentryOptionsFactory {
         createSentryModuleOptions(): SentryModuleOptions {
             return config;
@@ -27,9 +48,31 @@ describe('SentryModule', () => {
             }).compile();
 
             const sentry = mod.get<SentryService>(SENTRY_TOKEN);
-            console.log('sentry', sentry);
             expect(sentry).toBeDefined();
             expect(sentry).toBeInstanceOf(SentryService);
+            expect(sentry.opts?.logger).toBeInstanceOf(ConsoleLogger);
+        });
+
+        it('should provide the sentry client with custom logger', async() => {
+            const mod = await Test.createTestingModule({
+                imports: [SentryModule.forRoot(configWithCustomLogger)],
+            }).compile();
+
+            const sentry = mod.get<SentryService>(SENTRY_TOKEN);
+            expect(sentry).toBeDefined();
+            expect(sentry).toBeInstanceOf(SentryService);
+            expect(sentry.opts?.logger).toBeInstanceOf(CustomLogger);
+        });
+
+        it('should provide the sentry client with no logger', async() => {
+            const mod = await Test.createTestingModule({
+                imports: [SentryModule.forRoot(configWithNoLogger)],
+            }).compile();
+
+            const sentry = mod.get<SentryService>(SENTRY_TOKEN);
+            expect(sentry).toBeDefined();
+            expect(sentry).toBeInstanceOf(SentryService);
+            expect(sentry.opts?.logger).toBeNull();
         });
     });
 
@@ -47,6 +90,37 @@ describe('SentryModule', () => {
                 const sentry = mod.get<SentryService>(SENTRY_TOKEN);
                 expect(sentry).toBeDefined();
                 expect(sentry).toBeInstanceOf(SentryService);
+                expect(sentry.opts?.logger).toBeInstanceOf(ConsoleLogger);
+            });
+
+            it('should provide sentry client with custom logger', async () => {
+                const mod = await Test.createTestingModule({
+                    imports: [
+                        SentryModule.forRootAsync({
+                            useFactory: () => (configWithCustomLogger),
+                        }),
+                    ]
+                }).compile();
+
+                const sentry = mod.get<SentryService>(SENTRY_TOKEN);
+                expect(sentry).toBeDefined();
+                expect(sentry).toBeInstanceOf(SentryService);
+                expect(sentry.opts?.logger).toBeInstanceOf(CustomLogger);
+            });
+
+            it('should provide sentry client with no logger', async () => {
+                const mod = await Test.createTestingModule({
+                    imports: [
+                        SentryModule.forRootAsync({
+                            useFactory: () => (configWithNoLogger),
+                        }),
+                    ]
+                }).compile();
+
+                const sentry = mod.get<SentryService>(SENTRY_TOKEN);
+                expect(sentry).toBeDefined();
+                expect(sentry).toBeInstanceOf(SentryService);
+                expect(sentry.opts?.logger).toBeNull();
             });
         })
     });

lib/__tests__/sentry.service.spec.ts

@@ -8,7 +8,6 @@ import { SENTRY_TOKEN } from "../sentry.constants";
 import * as Sentry from '@sentry/node';
 jest.spyOn(Sentry, 'close')
   .mockImplementation(() => Promise.resolve(true));
-const mockCloseSentry = Sentry.close as jest.MockedFunction<typeof Sentry.close>;
 
 const SENTRY_NOT_CONFIGURE_ERROR = 'Please confirm that Sentry is configured correctly';
 
@@ -20,16 +19,32 @@ describe('SentryService', () => {
         logLevel: LogLevel.Debug,
     };
 
+    let configWithNoLogger: SentryModuleOptions = {
+        dsn: 'https://[email protected]/25956308132020',
+        debug: true,
+        environment: 'development',
+        logLevel: LogLevel.Debug,
+        logger: null
+    };
+
     let failureConfig: SentryModuleOptions = {
         dsn: 'https://[email protected]/1512xxx',
         debug: true,
         environment: 'development',
         logLevel: LogLevel.Debug,
     };
 
-    class TestService implements SentryOptionsFactory {
+    let failureConfigNoLogger: SentryModuleOptions = {
+        dsn: 'https://[email protected]/1512xxx',
+        debug: true,
+        environment: 'development',
+        logLevel: LogLevel.Debug,
+        logger: null
+    };
+
+    class TestServiceNoLogging implements SentryOptionsFactory {
         createSentryModuleOptions(): SentryModuleOptions {
-            return config;
+            return configWithNoLogger;
         }
     }
 
@@ -39,6 +54,12 @@ describe('SentryService', () => {
         }
     }
 
+    class FailureServiceNoLogging implements SentryOptionsFactory {
+        createSentryModuleOptions(): SentryModuleOptions {
+            return failureConfigNoLogger;
+        }
+    }
+
     describe('sentry.log:error', () => {
         it('should provide the sentry client and call log', async() => {
             const mod = await Test.createTestingModule({
@@ -54,6 +75,21 @@ describe('SentryService', () => {
             fail.log('sentry:log');
             expect(fail.log).toBeInstanceOf(Function);
         });
+
+        it('should provide the sentry client and call log with disabled logging', async() => {
+            const mod = await Test.createTestingModule({
+                imports: [
+                    SentryModule.forRootAsync({
+                        useClass: FailureServiceNoLogging
+                    })
+                ]
+            }).compile();
+
+            const fail = mod.get<SentryService>(SENTRY_TOKEN);
+            console.log('sentry:error', fail);
+            fail.log('sentry:log');
+            expect(fail.log).toBeInstanceOf(Function);
+        });
     });
 
     describe('sentry.log', () => {
@@ -72,6 +108,24 @@ describe('SentryService', () => {
             expect(sentry.log).toBeInstanceOf(Function);
             expect(true).toBeTruthy();
         });
+
+        it('should provide the sentry client and call log with disabled logging', async() => {
+            const mod = await Test.createTestingModule({
+                imports: [
+                    SentryModule.forRootAsync({
+                        useClass: TestServiceNoLogging
+                    })
+                ]
+            }).compile();
+
+            const sentry = mod.get<SentryService>(SENTRY_TOKEN);
+            expect(sentry).toBeDefined();
+            expect(sentry).toBeInstanceOf(SentryService);
+            console.log('sentry', sentry);
+            sentry.log('sentry:log');
+            expect(sentry.log).toBeInstanceOf(Function);
+            expect(true).toBeTruthy();
+        });
     });
 
     describe('sentry.error', () => {
@@ -276,5 +330,5 @@ describe('SentryService', () => {
             }
         })
     })
-    
+
 });

lib/sentry-core.module.ts

@@ -25,9 +25,9 @@ export class SentryCoreModule {
         const provider = createSentryProviders(options);
 
         return {
-            exports: [provider, SentryService],
+            exports: [provider],
             module: SentryCoreModule,
-            providers: [provider, SentryService],
+            providers: [provider],
         };
     }
 

lib/sentry.interfaces.ts

@@ -1,18 +1,23 @@
 import { ModuleMetadata, Type } from "@nestjs/common/interfaces";
 import { Integration, Options } from '@sentry/types';
 import { Severity } from "@sentry/node";
-import { ConsoleLoggerOptions } from "@nestjs/common";
+import { ConsoleLoggerOptions, LoggerService } from '@nestjs/common';
 
 export interface SentryCloseOptions {
     enabled: boolean;
     // timeout – Maximum time in ms the client should wait until closing forcefully
     timeout?: number;
 }
 
+export interface LoggingOptions {
+    logger?: LoggerService | null;
+    loggerOptions?: ConsoleLoggerOptions;
+}
+
 export type SentryModuleOptions = Omit<Options, 'integrations'> & {
     integrations?: Integration[];
     close?: SentryCloseOptions
-} & ConsoleLoggerOptions;
+} & LoggingOptions;
 
 export interface SentryOptionsFactory {
     createSentryModuleOptions(): Promise<SentryModuleOptions> | SentryModuleOptions;