Added the configurable option to display the method name from where the $log method is called.

justinkames · justinkames · commit d4ddfa8aff9d · 2017-10-16T14:49:39.000+02:00
Updated the README.md.
diff --git a/.gitignore b/.gitignore
@@ -2,4 +2,5 @@
 /node_modules/
 .idea
 coverage/
-package-lock.json
+package-lock.json
+sample-project
diff --git a/README.md b/README.md
@@ -56,7 +56,9 @@ const options = {
     // optional : defaults to false if not specified
     stringifyArguments : false,
     // optional : defaults to false if not specified
-    showLogLevel : false
+    showLogLevel : false,
+    // optional : defaults to false if not specified
+    showMethodName : false
 }
 
 Vue.use(VueLogger, options)
diff --git a/package.json b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "vuejs-logger",
   "author": "Justin Kames",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "description": "Vuejs-logger, provides customizable logging functionality for Vue.js.",
   "main": "dist/index.js",
   "repository": {
diff --git a/src/logger.js b/src/logger.js
@@ -1,32 +1,36 @@
-export default  (() => {
+export default (function () {
 
     const logLevels = ['debug', 'info', 'warn', 'error', 'fatal']
 
     function initLoggerInstance (options, logLevels) {
         const logger = {}
         logLevels.forEach(logLevel => {
-            if (logLevels.indexOf(logLevel) >= logLevels.indexOf(options.logLevel)) {
-                logger[logLevel] = (...args) => {
-                    const prefix = options.showLogLevel ? logLevel + ' | ' : ''
-                    const formattedArguments = options.stringifyArguments ? args.map(a => JSON.stringify(a)) : args
-                    print(logLevel, prefix, formattedArguments)
-                }
-            } else {
-                logger[logLevel] = () => {}
-            }
-        })
+              if (logLevels.indexOf(logLevel) >= logLevels.indexOf(options.logLevel)) {
+                  logger[logLevel] = (...args) => {
+                      let methodName = getMethodName()
+                      const methodNamePrefix = options.showMethodName ? methodName + ' | ' : ''
+                      const logLevelPrefix = options.showLogLevel ? logLevel + ' | ' : ''
+                      const formattedArguments = options.stringifyArguments ? args.map(a => JSON.stringify(a)) : args
+                      print(logLevel, logLevelPrefix, methodNamePrefix, formattedArguments)
+                  }
+              }
+              else {
+                  logger[logLevel] = () => {}
+              }
+          }
+        )
         return logger
     }
 
-    function print (logLevel, prefix, formattedArguments) {
+    function print (logLevel = false, logLevelPrefix = false, methodNamePrefix = false, formattedArguments = false) {
         if (logLevel === 'warn' || logLevel === 'error' || logLevel === 'fatal') {
-            console[logLevel === 'fatal' ? 'error' : logLevel](prefix, ...formattedArguments)
+            console[logLevel === 'fatal' ? 'error' : logLevel](logLevelPrefix, methodNamePrefix, ...formattedArguments)
         } else {
-            console.log(prefix, ...formattedArguments)
+            console.log(logLevelPrefix, methodNamePrefix, ...formattedArguments)
         }
     }
 
-    function validateOptions (options, logLevels) {
+    function isValidOptions (options, logLevels) {
         if (!(options.logLevel && typeof options.logLevel === 'string' && logLevels.indexOf(options.logLevel) > -1)) {
             return false
         }
@@ -36,23 +40,35 @@ export default  (() => {
         if (options.showLogLevel && typeof options.showLogLevel !== 'boolean') {
             return false
         }
-        return true
+        return !(options.showMethodName && typeof options.showMethodName !== 'boolean')
     }
 
     function install (Vue, options) {
-        if (validateOptions(options, logLevels)) {
+        if (isValidOptions(options, logLevels)) {
             Vue.$log = initLoggerInstance(options, logLevels)
             Vue.prototype.$log = Vue.$log
         } else {
             throw new Error('Provided options for vuejs-logger are not valid.')
         }
     }
 
+    function getMethodName () {
+        let stackTrace = Error().stack.split('\n')[3]
+        if (/ /.test(stackTrace)) {
+            stackTrace = stackTrace.trim().split(' ')[1]
+        }
+        if (stackTrace.includes('.')) {
+            stackTrace = stackTrace.split('.')[1]
+        }
+        return stackTrace
+    }
+
     return {
         install,
-        validateOptions,
+        isValidOptions,
         print,
         initLoggerInstance,
         logLevels
     }
-})()
+})
+()
diff --git a/test/logger.js b/test/logger.js
@@ -1,34 +1,49 @@
-import chai from 'chai'
-import Vue from 'vue'
+import Vue from 'vue/dist/vue.min'
 import VueLogger from '../src/logger'
+import chai from 'chai'
 
+const {print, isValidOptions, initLoggerInstance, logLevels, install} = VueLogger
 const expect = chai.expect
-const {print, validateOptions, initLoggerInstance, logLevels, install} = VueLogger
 
 describe('Logger.js', () => {
-
-    describe('install()', () => {
-
-        it('install() should work with the correct params.', () => {
+    describe('getMethodName()', () => {
+        it('Should show the parent function.', () => {
             const options = {
                 logLevel: 'debug',
                 stringifyByDefault: false,
                 showLogLevel: false,
+                showMethodName: true
             }
-
             Vue.use({install}, options)
 
             new Vue({
-                created() {
-                    expect(this.$log).to.be.a('object')
-                    expect(this.$log.debug).to.be.a('function')
-                    expect(this.$log.info).to.be.a('function')
-                    expect(this.$log.warn).to.be.a('function')
-                    expect(this.$log.error).to.be.a('function')
-                    expect(this.$log.fatal).to.be.a('function')
+                created () {
+                    this.foo()
+                },
+                template: '<bar></bar>',
+                methods: {
+                    foo () {
+                        this.$log.fatal('first level call.')
+                        externalFunction()
+                    }
                 }
             })
 
+            function externalFunction () {
+                Vue.$log.fatal('calling external function.')
+            }
+        })
+    })
+    describe('install()', () => {
+
+        it('install() should work with the correct params.', () => {
+            const options = {
+                logLevel: 'debug',
+                stringifyByDefault: false,
+                showLogLevel: false,
+                showMethodName: false
+            }
+            Vue.use({install}, options)
             expect(Vue.$log).to.be.a('object')
             expect(Vue.$log.debug).to.be.a('function')
             expect(Vue.$log.info).to.be.a('function')
@@ -37,6 +52,15 @@ describe('Logger.js', () => {
             expect(Vue.$log.fatal).to.be.a('function')
         })
 
+        it('install() should throw an error with the an incorrect log showMethodName parameter.', () => {
+            const options = {
+                showMethodName: 'foo'
+            }
+            expect(() => { install(Vue, options) })
+              .to
+              .throw(Error, 'Provided options for vuejs-logger are not valid.')
+        })
+
         it('install() should throw an error with the an incorrect log level.', () => {
             const options = {
                 logLevel: 'foo'
@@ -76,17 +100,26 @@ describe('Logger.js', () => {
 
     describe('initLoggerInstance()', () => {
 
-        it('initLoggerInstance() should ignore logLevels that are more restrictive than set logLevel.', () => {
+        it('initLoggerInstance() should ignore logLevels that are more restrictive than set logLevel.', function testFn () {
             // with options enabled
-            const a = initLoggerInstance({logLevel: 'info', showLogLevel: true, stringifyArguments: true}, logLevels)
+            const a = initLoggerInstance({
+                logLevel: 'info',
+                showLogLevel: true,
+                stringifyArguments: true,
+                showMethodName: false
+            }, logLevels)
             a.debug('test')
             a.info('test', ['test args'], ['test args'])
             a.warn('test', ['test args'])
             a.error('test', 'test args')
             a.fatal('test', ['test args'], 'test args', 'test args')
-
             // with options disabled
-            const b = initLoggerInstance({logLevel: 'info', showLogLevel: false, stringifyArguments: false}, logLevels)
+            const b = initLoggerInstance({
+                logLevel: 'info',
+                showLogLevel: false,
+                stringifyArguments: false,
+                showMethodName: true
+            }, logLevels)
             b.debug('test')
             b.info('test', ['test args'], ['test args'])
             b.warn('test', ['test args'])
@@ -95,49 +128,62 @@ describe('Logger.js', () => {
         })
     })
 
-    describe('validateOptions()', () => {
+    describe('isValidOptions()', () => {
 
-        it('validateOptions() should pass with correct options.', () => {
-            expect(validateOptions({
+        it('isValidOptions() should pass with correct options.', () => {
+            expect(isValidOptions({
                 logLevel: 'debug',
                 stringifyByDefault: false,
                 showLogLevel: false,
+                showMethodName: true
             }, logLevels)).to.equal(true)
         })
 
-        it('validateOptions() should fail with incorrect options.', () => {
-            expect(validateOptions({
+        it('isValidOptions() should fail with incorrect options.', () => {
+
+            expect(isValidOptions({
+                logLevel: 'debug',
+                stringifyArguments: false,
+                showLogLevel: false,
+                showMethodName: 'TEST',
+            }, logLevels)).to.equal(false)
+
+            expect(isValidOptions({
                 logLevel: 'debug',
                 stringifyArguments: 'TEST',
                 showLogLevel: false,
+                showMethodName: false,
             }, logLevels)).to.equal(false)
 
-            expect(validateOptions({
+            expect(isValidOptions({
                 logLevel: 'debug',
                 stringifyArguments: false,
                 showLogLevel: 'TEST',
+                showMethodName: false,
             }, logLevels)).to.equal(false)
 
-            expect(validateOptions({
+            expect(isValidOptions({
                 logLevel: 'TEST',
                 stringifyArguments: false,
                 showLogLevel: false,
+                showMethodName: false,
             }, logLevels)).to.equal(false)
+
+            expect(isValidOptions({
+                logLevel: 'debug',
+            }, logLevels)).to.equal(true)
         })
     })
 
     describe('print()', () => {
-
         it('print() should use console.error() with fatal logLevel', () => {
-            print('fatal', 'fatal |', ['test'])
+            print('fatal', 'fatal |', 'METHOD NAME | ', ['test'])
         })
-
         it('print() should use console.error() with error logLevel', () => {
-            print('error', 'error |', ['test'])
+            print('error', 'error |', 'METHOD NAME |', ['test'])
         })
-
         it('print() should use console.log() with any other logLevel', () => {
-            print('debug', 'debug |', ['test'])
+            print('debug', 'debug |', 'METHOD NAME |', ['test'])
         })
     })
 })

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "vuejs-logger",`
`3`	`3`	`"author": "Justin Kames",`
`4`		`- "version": "1.1.4",`
	`4`	`+ "version": "1.2.0",`
`5`	`5`	`"description": "Vuejs-logger, provides customizable logging functionality for Vue.js.",`
`6`	`6`	`"main": "dist/index.js",`
`7`	`7`	`"repository": {`