Merge pull request #539 from marle3003/develop

Develop

Author: marle3003

docs/resources/blogs/debugging-mokapi-scripts.md

@@ -70,6 +70,8 @@ In this case, because the handler returns true, Mokapi will:
 This visibility is incredibly helpful when debugging complex request flows, especially if you have 
 multiple handlers reacting to a single request.
 
+<img src="/dashboard-event-handler-debugging.png" alt="Mokapi dashboard displaying event handler logs for a specific HTTP request." class="image shadow">
+
 ## Best Practices for Debugging
 
 - Use console.log freely during development to trace values and decisions inside your scripts. 

engine/common/host.go

@@ -51,6 +51,7 @@ type Logger interface {
 	Warn(args ...interface{})
 	Error(args ...interface{})
 	Debug(args ...interface{})
+	IsLevelEnabled(level string) bool
 }
 
 type KafkaClient interface {

engine/engine.go

@@ -27,7 +27,7 @@ func New(reader dynamic.Reader, app *runtime.App, config *static.Config, paralle
 	return &Engine{
 		scripts:     make(map[string]*scriptHost),
 		scheduler:   NewDefaultScheduler(),
-		logger:      log.StandardLogger(),
+		logger:      newLogger(log.StandardLogger()),
 		reader:      reader,
 		kafkaClient: NewKafkaClient(app),
 		parallel:    parallel,
@@ -39,7 +39,7 @@ func NewEngine(opts ...Options) *Engine {
 	e := &Engine{
 		scripts:   make(map[string]*scriptHost),
 		scheduler: NewDefaultScheduler(),
-		logger:    log.StandardLogger(),
+		logger:    newLogger(log.StandardLogger()),
 	}
 	for _, opt := range opts {
 		opt(e)
@@ -134,3 +134,7 @@ func (e *Engine) Scripts() int {
 	defer e.m.Unlock()
 	return len(e.scripts)
 }
+
+func (e *Engine) IsLevelEnabled(level string) bool {
+	return e.logger.IsLevelEnabled(level)
+}

engine/enginetest/host.go

@@ -10,19 +10,20 @@ import (
 )
 
 type Host struct {
-	OpenFileFunc      func(file, hint string) (string, string, error)
-	OpenFunc          func(file, hint string) (*dynamic.Config, error)
-	InfoFunc          func(args ...interface{})
-	WarnFunc          func(args ...interface{})
-	ErrorFunc         func(args ...interface{})
-	DebugFunc         func(args ...interface{})
-	HttpClientTest    *HttpClient
-	KafkaClientTest   *KafkaClient
-	EveryFunc         func(every string, do func(), opt common.JobOptions)
-	CronFunc          func(every string, do func(), opt common.JobOptions)
-	OnFunc            func(event string, do func(args ...interface{}) (bool, error), tags map[string]string)
-	FindFakerNodeFunc func(name string) *common.FakerTree
-	m                 sync.Mutex
+	OpenFileFunc       func(file, hint string) (string, string, error)
+	OpenFunc           func(file, hint string) (*dynamic.Config, error)
+	InfoFunc           func(args ...interface{})
+	WarnFunc           func(args ...interface{})
+	ErrorFunc          func(args ...interface{})
+	DebugFunc          func(args ...interface{})
+	IsLevelEnabledFunc func(level string) bool
+	HttpClientTest     *HttpClient
+	KafkaClientTest    *KafkaClient
+	EveryFunc          func(every string, do func(), opt common.JobOptions)
+	CronFunc           func(every string, do func(), opt common.JobOptions)
+	OnFunc             func(event string, do func(args ...interface{}) (bool, error), tags map[string]string)
+	FindFakerNodeFunc  func(name string) *common.FakerTree
+	m                  sync.Mutex
 }
 
 type HttpClient struct {
@@ -58,6 +59,13 @@ func (h *Host) Debug(args ...interface{}) {
 	}
 }
 
+func (h *Host) IsLevelEnabled(level string) bool {
+	if h.IsLevelEnabledFunc == nil {
+		return true
+	}
+	return h.IsLevelEnabledFunc(level)
+}
+
 func (h *Host) OpenFile(file, hint string) (*dynamic.Config, error) {
 	if h.OpenFileFunc != nil {
 		p, src, err := h.OpenFileFunc(file, hint)

engine/enginetest/logger.go

@@ -1,10 +1,11 @@
 package enginetest
 
 type Logger struct {
-	InfoFunc  func(args ...interface{})
-	WarnFunc  func(args ...interface{})
-	ErrorFunc func(args ...interface{})
-	DebugFunc func(args ...interface{})
+	InfoFunc           func(args ...interface{})
+	WarnFunc           func(args ...interface{})
+	ErrorFunc          func(args ...interface{})
+	DebugFunc          func(args ...interface{})
+	IsLevelEnabledFunc func(level string) bool
 }
 
 func (l *Logger) Info(args ...interface{}) {
@@ -34,3 +35,10 @@ func (l *Logger) Debug(args ...interface{}) {
 	}
 	l.DebugFunc(args...)
 }
+
+func (l *Logger) IsLevelEnabled(level string) bool {
+	if l.IsLevelEnabledFunc == nil {
+		return true
+	}
+	return l.IsLevelEnabledFunc(level)
+}

engine/eventhandler_test.go

@@ -2,6 +2,7 @@ package engine_test
 
 import (
 	"github.com/stretchr/testify/require"
+	"mokapi/engine"
 	"mokapi/engine/common"
 	"mokapi/engine/enginetest"
 	"testing"
@@ -11,6 +12,7 @@ func TestEventHandler(t *testing.T) {
 	testcases := []struct {
 		name   string
 		script string
+		logger *enginetest.Logger
 		run    func(evt common.EventEmitter) []*common.Action
 		test   func(t *testing.T, actions []*common.Action, err error)
 	}{
@@ -50,6 +52,48 @@ export default () => {
 				require.Len(t, actions, 1)
 				require.Len(t, actions[0].Logs, 1)
 				require.Equal(t, "a log message from event handler", actions[0].Logs[0].Message)
+				require.Equal(t, "log", actions[0].Logs[0].Level)
+			},
+		},
+		{
+			name: "console.warn",
+			script: `import { on } from 'mokapi'
+export default () => {
+	on('http', () => {
+		console.warn('a log message from event handler')
+		return true
+	})
+}
+`,
+			run: func(evt common.EventEmitter) []*common.Action {
+				return evt.Emit("http")
+			},
+			test: func(t *testing.T, actions []*common.Action, err error) {
+				require.NoError(t, err)
+				require.Len(t, actions, 1)
+				require.Len(t, actions[0].Logs, 1)
+				require.Equal(t, "a log message from event handler", actions[0].Logs[0].Message)
+				require.Equal(t, "warn", actions[0].Logs[0].Level)
+			},
+		},
+		{
+			name: "console.warn but not match log level",
+			script: `import { on } from 'mokapi'
+export default () => {
+	on('http', () => {
+		console.warn('a log message from event handler')
+		return true
+	})
+}
+`,
+			logger: &enginetest.Logger{IsLevelEnabledFunc: func(level string) bool { return false }},
+			run: func(evt common.EventEmitter) []*common.Action {
+				return evt.Emit("http")
+			},
+			test: func(t *testing.T, actions []*common.Action, err error) {
+				require.NoError(t, err)
+				require.Len(t, actions, 1)
+				require.Len(t, actions[0].Logs, 0)
 			},
 		},
 		{
@@ -110,7 +154,12 @@ export default () => {
 		t.Run(tc.name, func(t *testing.T) {
 			t.Parallel()
 
-			e := enginetest.NewEngine()
+			var opts []engine.Options
+			if tc.logger != nil {
+				opts = append(opts, engine.WithLogger(tc.logger))
+			}
+
+			e := enginetest.NewEngine(opts...)
 			err := e.AddScript(newScript("test.js", tc.script))
 
 			var actions []*common.Action

engine/host.go

@@ -188,32 +188,36 @@ func (sh *scriptHost) close() {
 
 func (sh *scriptHost) Info(args ...interface{}) {
 	sh.engine.logger.Info(args...)
-	if sh.actionLogger != nil {
+	if sh.actionLogger != nil && sh.IsLevelEnabled("info") {
 		sh.actionLogger("log", fmt.Sprint(args...))
 	}
 }
 
 func (sh *scriptHost) Warn(args ...interface{}) {
 	sh.engine.logger.Warn(args...)
-	if sh.actionLogger != nil {
+	if sh.actionLogger != nil && sh.IsLevelEnabled("warn") {
 		sh.actionLogger("warn", fmt.Sprint(args...))
 	}
 }
 
 func (sh *scriptHost) Error(args ...interface{}) {
 	sh.engine.logger.Error(args...)
-	if sh.actionLogger != nil {
+	if sh.actionLogger != nil && sh.IsLevelEnabled("error") {
 		sh.actionLogger("error", fmt.Sprint(args...))
 	}
 }
 
 func (sh *scriptHost) Debug(args ...interface{}) {
 	sh.engine.logger.Debug(args...)
-	if sh.actionLogger != nil {
+	if sh.actionLogger != nil && sh.IsLevelEnabled("debug") {
 		sh.actionLogger("debug", fmt.Sprint(args...))
 	}
 }
 
+func (e *scriptHost) IsLevelEnabled(level string) bool {
+	return e.engine.IsLevelEnabled(level)
+}
+
 func (sh *scriptHost) OpenFile(path string, hint string) (*dynamic.Config, error) {
 	u, err := url.Parse(path)
 	if err != nil || len(u.Scheme) == 0 || len(u.Opaque) > 0 {

engine/kafka_test.go

@@ -42,7 +42,7 @@ func TestKafkaClient_Produce_Empty_Parameter(t *testing.T) {
 	app := runtime.New(&static.Config{})
 	e := enginetest.NewEngine(
 		engine.WithKafkaClient(engine.NewKafkaClient(app)),
-		engine.WithLogger(logrus.StandardLogger()),
+		engine.WithDefaultLogger(),
 	)
 
 	info, err := app.Kafka.Add(getConfig(config), e)
@@ -345,7 +345,7 @@ func TestKafkaClient_Produce(t *testing.T) {
 			app := runtime.New(&static.Config{})
 			e := enginetest.NewEngine(
 				engine.WithKafkaClient(engine.NewKafkaClient(app)),
-				engine.WithLogger(logrus.StandardLogger()),
+				engine.WithDefaultLogger(),
 			)
 
 			info, err := app.Kafka.Add(getConfig(config), e)

engine/logger.go

@@ -0,0 +1,35 @@
+package engine
+
+import log "github.com/sirupsen/logrus"
+
+type logger struct {
+	logger *log.Logger
+}
+
+func newLogger(l *log.Logger) *logger {
+	return &logger{logger: l}
+}
+
+func (l *logger) Debug(args ...interface{}) {
+	l.logger.Debug(args...)
+}
+
+func (l *logger) Info(args ...interface{}) {
+	l.logger.Info(args...)
+}
+
+func (l *logger) Error(args ...interface{}) {
+	l.logger.Error(args...)
+}
+
+func (l *logger) Warn(args ...interface{}) {
+	l.logger.Warn(args...)
+}
+
+func (l *logger) IsLevelEnabled(level string) bool {
+	lvl, err := log.ParseLevel(level)
+	if err != nil {
+		return false
+	}
+	return l.logger.IsLevelEnabled(lvl)
+}

engine/options.go

@@ -1,6 +1,7 @@
 package engine
 
 import (
+	"github.com/sirupsen/logrus"
 	"mokapi/config/dynamic"
 	"mokapi/engine/common"
 )
@@ -29,6 +30,12 @@ func WithScheduler(scheduler Scheduler) Options {
 	}
 }
 
+func WithDefaultLogger() Options {
+	return func(e *Engine) {
+		e.logger = newLogger(logrus.StandardLogger())
+	}
+}
+
 func WithLogger(logger common.Logger) Options {
 	return func(e *Engine) {
 		e.logger = logger