Add loggin layer

Author: santiq

src/api/middlewares/attachCurrentUser.ts

@@ -9,6 +9,7 @@ import { IUser } from '../../interfaces/IUser';
  * @param {*} next  Express next Function
  */
 const attachCurrentUser = async (req, res, next) => {
+  const Logger = Container.get('logger');
   try {
     const UserModel = Container.get('userModel') as mongoose.Model<IUser & mongoose.Document>;
     const userRecord = await UserModel.findById(req.token._id);
@@ -21,8 +22,8 @@ const attachCurrentUser = async (req, res, next) => {
     req.currentUser = currentUser;
     return next();
   } catch (e) {
-    console.log('🔥 Error attaching user to req');
-    console.log(e);
+    Logger.warn('🔥 Error attaching user to req');
+    Logger.warn(e);
     return next(e);
   }
 };

src/api/routes/auth.ts

@@ -20,12 +20,13 @@ export default (app: Router) => {
       }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
+      const logger = Container.get('logger');
       try {
         const authServiceInstance = Container.get(AuthService);
         const { user, token } = await authServiceInstance.SignUp(req.body as IUserInputDTO);
         return res.json({ user, token }).status(201);
       } catch (e) {
-        console.log('🔥 error ', e);
+        logger.warn('🔥 error ', e);
         return next(e);
       }
     },
@@ -40,13 +41,14 @@ export default (app: Router) => {
       }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
+      const Logger = Container.get('logger');
       try {
         const { email, password } = req.body;
         const authServiceInstance = Container.get(AuthService);
         const { user, token } = await authServiceInstance.SignIn(email, password);
         return res.json({ user, token }).status(200);
       } catch (e) {
-        console.log('🔥 error ', e);
+        Logger.warn('🔥 error ', e);
         return next(e);
       }
     },
@@ -62,11 +64,12 @@ export default (app: Router) => {
    * It's really annoying to develop that but if you had to, please use Redis as your data store
    */
   route.post('/logout', middlewares.isAuth, (req: Request, res: Response, next: NextFunction) => {
+    const Logger = Container.get('logger');
     try {
       //@TODO AuthService.Logout(req.user) do some clever stuff
       return res.status(200).end();
     } catch (e) {
-      console.log('🔥 error ', e);
+      Logger.warn('🔥 error ', e);
       return next(e);
     }
   });

src/app.ts

@@ -4,6 +4,8 @@ import config from './config';
 
 import * as express from 'express';
 
+import Logger from './loaders/logger';
+
 async function startServer() {
   const app = express();
 
@@ -17,11 +19,11 @@ async function startServer() {
 
   app.listen(config.port, err => {
     if (err) {
-      console.log(err);
+      Logger.warn(err);
       process.exit(1);
       return;
     }
-    console.log(`
+    Logger.debug(`
       ################################################
       🛡️  Server listening on port: ${config.port} 🛡️ 
       ################################################

src/config/index.ts

@@ -28,10 +28,9 @@ export default {
 
   /**
    * Used by winston logger
-   * @TODO Wait for it...
    */
   logs: {
-    level: process.env.LOG_LEVEL,
+    level: process.env.LOG_LEVEL || 'debug',
   },
 
   /**

src/jobs/emailSequence.ts

@@ -3,15 +3,16 @@ import MailerService from '../services/mailer';
 
 export default class EmailSequenceJob {
   public async handler(job, done): Promise<void> {
-    console.log('✌️ Email Sequence Job triggered!');
+    const Logger = Container.get('logger');
     try {
+      Logger.debug('✌️ Email Sequence Job triggered!');
       const { email, name }: { [key: string]: string } = job.data;
       const mailerServiceInstance = Container.get(MailerService);
       await mailerServiceInstance.StartEmailSequence('WelcomeSequence', { email, name });
       done();
     } catch (e) {
-      console.log('🔥 Error with Email Sequence Job');
-      console.log(e);
+      Logger.warn('🔥 Error with Email Sequence Job');
+      Logger.warn(e);
       done(e);
     }
   }

src/loaders/dependencyInjector.ts

@@ -1,5 +1,5 @@
 import { Container } from 'typedi';
-
+import LoggerInstance from './logger';
 import agendaFactory from './agenda';
 
 export default ({ mongoConnection, models }: { mongoConnection; models: { name: string; model: any }[] }) => {
@@ -11,12 +11,13 @@ export default ({ mongoConnection, models }: { mongoConnection; models: { name:
     const agendaInstance = agendaFactory({ mongoConnection });
 
     Container.set('agendaInstance', agendaInstance);
+    Container.set('logger', LoggerInstance)
 
-    console.log('✌️ Agenda injected into container');
+    LoggerInstance.debug('✌️ Agenda injected into container');
 
     return { agenda: agendaInstance };
   } catch (e) {
-    console.log('🔥 Error on dependency injector loader %o', e);
+    LoggerInstance.debug('🔥 Error on dependency injector loader %o', e);
     throw e;
   }
 };

src/loaders/index.ts

@@ -2,10 +2,10 @@ import expressLoader from './express';
 import dependencyInjectorLoader from './dependencyInjector';
 import mongooseLoader from './mongoose';
 import jobsLoader from './jobs';
-
+import Logger from './logger';
 export default async ({ expressApp }) => {
   const mongoConnection = await mongooseLoader();
-  console.log('✌️ DB loaded and connected!');
+  Logger.debug('✌️ DB loaded and connected!');
 
   /**
    * WTF is going on here?
@@ -30,11 +30,11 @@ export default async ({ expressApp }) => {
       // whateverModel
     ],
   });
-  console.log('✌️ Dependency Injector loaded');
+  Logger.debug('✌️ Dependency Injector loaded');
 
   await jobsLoader({ agenda });
-  console.log('✌️ Jobs loaded');
+  Logger.debug('✌️ Jobs loaded');
 
   await expressLoader({ app: expressApp });
-  console.log('✌️ Express loaded');
+  Logger.debug('✌️ Express loaded');
 };

src/loaders/logger.ts

@@ -0,0 +1,34 @@
+import * as winston from 'winston';
+import config from '../config';
+
+const transports = [];
+if(process.env.NODE_ENV !== 'development') {
+  transports.push(
+    new winston.transports.Console()
+  )
+} else {
+  transports.push(
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.cli(),
+        winston.format.splat(),
+      )
+    })
+  )
+}
+
+const LoggerInstance = winston.createLogger({
+  level: config.logs.level,
+  levels: winston.config.npm.levels,
+  format: winston.format.combine(
+    winston.format.timestamp({
+      format: 'YYYY-MM-DD HH:mm:ss'
+    }),
+    winston.format.errors({ stack: true }),
+    winston.format.splat(),
+    winston.format.json()
+  ),
+  transports
+});
+
+export default LoggerInstance;

src/services/auth.ts

@@ -8,7 +8,11 @@ import { IUser, IUserInputDTO } from '../interfaces/IUser';
 
 @Service()
 export default class AuthService {
-  constructor(@Inject('userModel') private userModel, private mailer: MailerService) {}
+  constructor(
+      @Inject('userModel') private userModel,
+      private mailer: MailerService,
+      @Inject('logger') private logger,
+    ) {}
 
   public async SignUp(userInputDTO: IUserInputDTO): Promise<{ user: IUser; token: string }> {
     try {
@@ -56,7 +60,7 @@ export default class AuthService {
       Reflect.deleteProperty(user, 'salt');
       return { user, token };
     } catch (e) {
-      console.log(e);
+      this.logger.warn(e);
       throw e;
     }
   }

src/subscribers/user.ts

@@ -18,20 +18,24 @@ export default class UserSubscriber {
    */
   @On(events.user.signIn)
   public onUserSignIn({ _id }: Partial<IUser>) {
+    const Logger = Container.get('logger');
+
     try {
       const UserModel = Container.get('UserModel') as mongoose.Model<IUser & mongoose.Document>;
 
       UserModel.update({ _id }, { $set: { lastLogin: new Date() } });
     } catch (e) {
-      console.log(`🔥 Error on event ${events.user.signIn}`);
-      console.log(e);
+      Logger.warn(`🔥 Error on event ${events.user.signIn}`);
+      Logger.warn(e);
 
       // Throw the error so the process die (check src/app.ts)
       throw e;
     }
   }
   @On(events.user.signUp)
   public onUserSignUp({ name, email, _id }: Partial<IUser>) {
+    const Logger = Container.get('logger');
+
     try {
       /**
        * @TODO implement this
@@ -42,8 +46,8 @@ export default class UserSubscriber {
       // Start your email sequence or whatever
       // MailService.startSequence('user.welcome', { email, name })
     } catch (e) {
-      console.log(`🔥 Error on event ${events.user.signUp}`);
-      console.log(e);
+      Logger.warn(`🔥 Error on event ${events.user.signUp}`);
+      Logger.warn(e);
 
       // Throw the error so the process dies (check src/app.ts)
       throw e;