feat: log level

cmd/client/apimonkey/instance.go

@@ -11,42 +11,51 @@ import (
 	"time"
 
 	"github.com/cockroachdb/errors"
-	"github.com/google/uuid"
 	"github.com/imroc/req/v3"
 	"github.com/rs/zerolog"
 	"github.com/tidwall/gjson"
 	"meow.tf/streamdeck/sdk"
 )
 
 type Instance struct {
-	cfg        *config
-	contextApp string
-	lg         zerolog.Logger
-	executor   ScriptExecutor
-	ctx        context.Context
-	ctxCancel  context.CancelFunc
-	mut        sync.Mutex
+	cfg           *config
+	contextApp    string
+	currentLogger zerolog.Logger
+	executor      ScriptExecutor
+	ctx           context.Context
+	ctxCancel     context.CancelFunc
+	mut           sync.Mutex
 }
 
 func NewInstance(
 	contextApp string,
 	executor ScriptExecutor,
+	logger zerolog.Logger,
 ) *Instance {
 	return &Instance{
-		contextApp: contextApp,
-		lg:         lg.With().Str("context_id", contextApp).Logger(),
-		executor:   executor,
-		mut:        sync.Mutex{},
+		contextApp:    contextApp,
+		currentLogger: logger.With().Str("context_id", contextApp).Logger(),
+		executor:      executor,
+		mut:           sync.Mutex{},
 	}
 }
 
+func (i *Instance) GetLogger() zerolog.Logger {
+	return i.currentLogger
+}
+
 func (i *Instance) SetConfig(ctxId string, cfg *config) {
 	if i.contextApp != ctxId {
 		return
 	}
 
 	i.cfg = cfg
-	lg.Debug().Msg("set config")
+
+	if i.cfg.MinLogLevel != nil {
+		i.currentLogger = i.currentLogger.Level(*i.cfg.MinLogLevel)
+	} else {
+		i.currentLogger = i.currentLogger.Level(zerolog.WarnLevel)
+	}
 }
 
 func (i *Instance) ShowAlert() {
@@ -55,7 +64,7 @@ func (i *Instance) ShowAlert() {
 
 func (i *Instance) KeyPressed() {
 	if i.cfg == nil {
-		lg.Error().Msg("global config not set")
+		i.currentLogger.Error().Msg("global config not set")
 		sdk.ShowAlert(i.contextApp)
 		return
 	}
@@ -65,12 +74,12 @@ func (i *Instance) KeyPressed() {
 		targetUrl = i.cfg.ApiUrl
 	}
 
-	targetUrl = runTemplate(targetUrl, i.cfg)
+	targetUrl = runTemplate(targetUrl, i.cfg, i.currentLogger)
 
 	if err := exec.Command("rundll32",
 		"url.dll,FileProtocolHandler", targetUrl).Start(); err != nil {
 
-		lg.Error().Msg("global config not set")
+		i.currentLogger.Error().Msg("global config not set")
 		sdk.ShowAlert(i.contextApp)
 		return
 	}
@@ -108,15 +117,14 @@ func (i *Instance) run() {
 			interval = i.cfg.IntervalSeconds
 		}
 
-		newLogger := lg.With().Str("id", uuid.NewString()).Logger()
 		innerCtx, innerCancel := context.WithCancel(ctx)
-		innerCtx = newLogger.WithContext(innerCtx)
+		innerCtx = i.currentLogger.WithContext(innerCtx)
 
 		processErr := i.sendAndProcess(innerCtx)
 		innerCancel()
 
 		if processErr != nil {
-			lg.Err(errors.Wrap(processErr, "error processing response")).Send()
+			i.currentLogger.Err(errors.Wrap(processErr, "error processing response")).Send()
 			i.ShowAlert()
 		} else {
 			if i.cfg.ShowSuccessNotification {
@@ -129,12 +137,12 @@ func (i *Instance) run() {
 }
 
 func (i *Instance) sendAndProcess(ctx context.Context) error {
-	apiUrl := runTemplate(i.cfg.ApiUrl, i.cfg)
+	apiUrl := runTemplate(i.cfg.ApiUrl, i.cfg, i.currentLogger)
 	httpReq := req.C().NewRequest()
 	httpReq = httpReq.SetContext(ctx)
 
 	for k, v := range i.cfg.Headers {
-		httpReq.SetHeader(k, runTemplate(v, i.cfg))
+		httpReq.SetHeader(k, runTemplate(v, i.cfg, i.currentLogger))
 	}
 
 	zerolog.Ctx(ctx).Trace().Str("url", apiUrl).Msg("sending request")
@@ -144,7 +152,7 @@ func (i *Instance) sendAndProcess(ctx context.Context) error {
 	}
 
 	value := resp.String()
-	zerolog.Ctx(ctx).Debug().Str("response", value).Msg("got raw response")
+	zerolog.Ctx(ctx).Trace().Str("response", value).Msg("got raw response")
 
 	if strings.TrimSpace(i.cfg.BodyScript) != "" {
 		zerolog.Ctx(ctx).Trace().Str("script", i.cfg.BodyScript).Msg("executing script")
@@ -185,14 +193,14 @@ func (i *Instance) sendAndProcess(ctx context.Context) error {
 		}
 	}
 
-	zerolog.Ctx(ctx).Debug().Str("final_result", value).Msgf("final")
+	zerolog.Ctx(ctx).Info().Str("final_result", value).Msgf("final")
 
 	return i.handleResponse(ctx, value)
 }
 
 func (i *Instance) handleResponse(_ context.Context, response string) error {
 	var sb strings.Builder
-	prefix := runTemplate(i.cfg.TitlePrefix, i.cfg)
+	prefix := runTemplate(i.cfg.TitlePrefix, i.cfg, i.currentLogger)
 	if prefix != "" {
 		sb.WriteString(strings.ReplaceAll(prefix, "\\n", "\n") + "\n")
 	}
@@ -217,7 +225,7 @@ func (i *Instance) handleResponse(_ context.Context, response string) error {
 		mapped = def
 	} else if !ok && !defaultOk {
 		sb.WriteString("!! NO !!\n !! MAPPING !!")
-		lg.Error().Msgf("response mapper not found for value - %v", response)
+		i.currentLogger.Error().Msgf("response mapper not found for value - %v", response)
 
 		sdk.SetTitle(i.contextApp, sb.String(), 0)
 		sdk.SetImage(i.contextApp, "", 0)

cmd/client/apimonkey/main.go

@@ -13,23 +13,27 @@ import (
 	"github.com/ft-t/streamdeck/cmd/scripts"
 )
 
-var lg zerolog.Logger
-
 var instances = map[string]*Instance{}
 var mut sync.Mutex
 
-func setSettingsFromPayload(payload *fastjson.Value, ctxId string, instance *Instance) {
+func setSettingsFromPayload(
+	payload *fastjson.Value,
+	ctxId string,
+	instance *Instance,
+) {
+	logger := instance.GetLogger()
+
 	if instance == nil {
-		lg.Warn().Msgf("instance %v not found", ctxId)
+		logger.Warn().Msgf("instance %v not found", ctxId)
 		return
 	}
 
 	settingsBytes := payload.MarshalTo(nil)
-	lg.Debug().Msgf("Got configuration: %v", string(settingsBytes))
+	logger.Trace().Msgf("Got configuration: %v", string(settingsBytes))
 	var tempConfig config
 
 	if err := json.Unmarshal(settingsBytes, &tempConfig); err != nil {
-		lg.Err(err).Send()
+		logger.Err(err).Send()
 		instance.ShowAlert()
 		return
 	}
@@ -46,7 +50,7 @@ func main() {
 		Compress:   false,
 	}
 
-	lg = zerolog.New(zerolog.MultiLevelWriter(os.Stdout, logFile)).With().Timestamp().Logger()
+	lg := zerolog.New(zerolog.MultiLevelWriter(os.Stdout, logFile)).With().Timestamp().Logger()
 
 	sdk.AddHandler(func(event *sdk.WillAppearEvent) {
 		if event.Payload == nil {
@@ -58,7 +62,7 @@ func main() {
 		instance, ok := instances[event.Context]
 
 		if !ok {
-			instance = NewInstance(event.Context, scripts.NewLua())
+			instance = NewInstance(event.Context, scripts.NewLua(), lg)
 			instances[event.Context] = instance
 		}
 

cmd/client/apimonkey/process.go

@@ -6,23 +6,28 @@ import (
 	"text/template"
 
 	"github.com/cockroachdb/errors"
+	"github.com/rs/zerolog"
 )
 
-func runTemplate(input string, cfg *config) string {
+func runTemplate(
+	input string,
+	cfg *config,
+	logger zerolog.Logger,
+) string {
 	if len(cfg.TemplateParameters) == 0 || len(input) == 0 {
 		return input
 	}
 
 	parsed, err := template.New("any").Parse(input)
 	if err != nil {
-		lg.Err(errors.Wrapf(err, "can not parse template - %v", err))
+		logger.Err(errors.Wrapf(err, "can not parse template - %v", err))
 		return input
 	}
 
 	var buf bytes.Buffer
 
 	if err = parsed.Execute(&buf, cfg.TemplateParameters); err != nil {
-		lg.Err(errors.Wrapf(err, "can not parse template - %v", err))
+		logger.Err(errors.Wrapf(err, "can not parse template - %v", err))
 		return input
 	}
 

cmd/client/apimonkey/resources/pi/pi.html

@@ -26,6 +26,17 @@
         <button class="sdpi-item-value" @click="save">Save All</button>
     </div>
     <hr>
+    <div class="sdpi-item" id="select_single2">
+        <div class="sdpi-item-label">Log Level</div>
+        <select class="sdpi-item-value select sdProperty" v-model="config.logLevel">
+            <option value="3">Error</option>
+            <option value="2" selected>Warn</option>
+            <option value="1">Info</option>
+            <option value="0">Debug</option>
+            <option value="-1">Trace</option>
+        </select>
+    </div>
+    <hr>
     <div class="sdpi-item" id="select_single">
         <div class="sdpi-item-label">Request Type</div>
         <select class="sdpi-item-value select sdProperty" v-model="config.methodType">

cmd/client/apimonkey/types.go

@@ -1,5 +1,7 @@
 package main
 
+import "github.com/rs/zerolog"
+
 type config struct {
 	ApiUrl                  string            `json:"apiUrl"`
 	BrowserUrl              string            `json:"browserUrl"`
@@ -11,4 +13,5 @@ type config struct {
 	TitlePrefix             string            `json:"titlePrefix"`
 	BodyScript              string            `json:"bodyScript"`
 	ShowSuccessNotification bool              `json:"showSuccessNotification"`
+	MinLogLevel             *zerolog.Level    `json:"logLevel"`
 }

cmd/scripts/lua_test.go

@@ -36,3 +36,29 @@ func TestLuaWithHeadersAndTemplate(t *testing.T) {
 	assert.NoError(t, err)
 	assert.Equal(t, "Hello, world!SomeValuevalue1", resp)
 }
+
+func TestHandleArray(t *testing.T) {
+	executor := scripts.NewLua()
+
+	resp, err := executor.Execute(context.TODO(), `
+		local json = require("json")
+   	    local data2, pos2, err2 = json.decode(_G.ResponseBody, 1, nil)
+
+		return data2["values"][1]["state"]`,
+		`{
+  "values": [
+    {
+      "state": "SUCCESSFUL"
+    }
+  ],
+  "pagelen": 10,
+  "size": 1,
+  "page": 1
+}`,
+		200,
+		nil,
+		nil,
+	)
+	assert.NoError(t, err)
+	assert.Equal(t, "SUCCESSFUL", resp)
+}