feat: integrate logger into function, cache, broker, account, oauth

Author: VladPetriv

account.go

@@ -2,7 +2,6 @@ package staticbackend
 
 import (
 	"fmt"
-	"log"
 	"math/rand"
 	"net/http"
 	"strings"
@@ -11,6 +10,7 @@ import (
 	"github.com/staticbackendhq/core/config"
 	emailFuncs "github.com/staticbackendhq/core/email"
 	"github.com/staticbackendhq/core/internal"
+	"github.com/staticbackendhq/core/logger"
 	"github.com/staticbackendhq/core/middleware"
 
 	"github.com/stripe/stripe-go/v72"
@@ -25,6 +25,7 @@ var (
 
 type accounts struct {
 	membership *membership
+	log        *logger.Logger
 }
 
 func (a *accounts) create(w http.ResponseWriter, r *http.Request) {
@@ -241,13 +242,13 @@ Refer to the documentation at https://staticbackend.com/docs\n
 	} else {
 		err = emailer.Send(ed)
 		if err != nil {
-			log.Println("error sending email", err)
+			a.log.Error().Err(err).Msg("error sending email")
 			http.Error(w, err.Error(), http.StatusInternalServerError)
 			return
 		}
 	}
 
-	fmt.Println("DEBUG: ", signUpURL)
+	a.log.Debug().Msgf("DEBUG: %s", signUpURL)
 
 	if fromCLI {
 		respond(w, http.StatusOK, signUpURL)
@@ -259,7 +260,7 @@ Refer to the documentation at https://staticbackend.com/docs\n
 		return
 	}
 
-	render(w, r, "login.html", nil, &Flash{Type: "sucess", Message: "We've emailed you all the information you need to get started."})
+	render(w, r, "login.html", nil, &Flash{Type: "sucess", Message: "We've emailed you all the information you need to get started."}, a.log)
 }
 
 func (a *accounts) auth(w http.ResponseWriter, r *http.Request) {

cache/cache.go

@@ -4,29 +4,30 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"log"
 	"time"
 
 	"github.com/staticbackendhq/core/config"
 	"github.com/staticbackendhq/core/internal"
+	"github.com/staticbackendhq/core/logger"
 
 	"github.com/go-redis/redis/v8"
 )
 
 type Cache struct {
 	Rdb *redis.Client
 	Ctx context.Context
+	log *logger.Logger
 }
 
 // NewCache returns an initiated Redis client
-func NewCache() *Cache {
+func NewCache(log *logger.Logger) *Cache {
 	var err error
 	var opt *redis.Options
 
 	if uri := config.Current.RedisURL; len(uri) > 0 {
 		opt, err = redis.ParseURL(uri)
 		if err != nil {
-			log.Fatal("invalid REDIS_URL value: ", err)
+			log.Fatal().Err(err).Msg("invalid REDIS_URL value")
 		}
 	} else {
 		opt = &redis.Options{
@@ -40,6 +41,7 @@ func NewCache() *Cache {
 	return &Cache{
 		Rdb: rdb,
 		Ctx: context.Background(),
+		log: log,
 	}
 }
 
@@ -83,7 +85,7 @@ func (c *Cache) Subscribe(send chan internal.Command, token, channel string, clo
 	pubsub := c.Rdb.Subscribe(c.Ctx, channel)
 
 	if _, err := pubsub.Receive(c.Ctx); err != nil {
-		log.Println("error establishing PubSub subscription", err)
+		c.log.Error().Err(err).Msg("error establishing PubSub subscription")
 		return
 	}
 
@@ -94,7 +96,7 @@ func (c *Cache) Subscribe(send chan internal.Command, token, channel string, clo
 		case m := <-ch:
 			var msg internal.Command
 			if err := json.Unmarshal([]byte(m.Payload), &msg); err != nil {
-				log.Println("error parsing JSON message", err)
+				c.log.Error().Err(err).Msg("error parsing JSON message")
 				_ = pubsub.Close()
 				return
 			}
@@ -129,14 +131,14 @@ func (c *Cache) Publish(msg internal.Command) error {
 		sysmsg.IsSystemEvent = true
 		b, err := json.Marshal(sysmsg)
 		if err != nil {
-			log.Println("error marshaling the system msg: ", err)
+			c.log.Error().Err(err).Msg("error marshaling the system msg")
 			return
 		}
 
 		sysctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
 		defer cancel()
 		if err := c.Rdb.Publish(sysctx, "sbsys", string(b)).Err(); err != nil {
-			log.Println("error publishing to system channel: ", err)
+			c.log.Error().Err(err).Msg("error publishing to system channel")
 		}
 	}(msg)
 
@@ -146,21 +148,21 @@ func (c *Cache) Publish(msg internal.Command) error {
 func (c *Cache) PublishDocument(channel, typ string, v interface{}) {
 	subs, err := c.Rdb.PubSubNumSub(c.Ctx, channel).Result()
 	if err != nil {
-		fmt.Println("error getting db subscribers for ", channel)
+		c.log.Error().Err(err).Msgf("error getting db subscribers for ", channel)
 		return
 	}
 
 	count, ok := subs[channel]
 	if !ok {
-		fmt.Println("cannot find channel in subs", channel)
+		c.log.Warn().Msgf("cannot find channel in subs: %d", channel)
 		return
 	} else if count == 0 {
 		return
 	}
 
 	b, err := json.Marshal(v)
 	if err != nil {
-		fmt.Println("error publishing db doc: ", err)
+		c.log.Error().Err(err).Msg("error publishing db doc")
 		return
 	}
 
@@ -171,7 +173,7 @@ func (c *Cache) PublishDocument(channel, typ string, v interface{}) {
 	}
 
 	if err := c.Publish(msg); err != nil {
-		fmt.Println("unable to publish db doc events:", err)
+		c.log.Error().Err(err).Msg("unable to publish db doc events")
 	}
 }
 
@@ -183,7 +185,8 @@ func (c *Cache) HasPermission(token, repo, payload string) bool {
 
 	docs := make(map[string]interface{})
 	if err := json.Unmarshal([]byte(payload), &docs); err != nil {
-		fmt.Println("error decoding docs for permissions check", err)
+		c.log.Error().Err(err).Msg("error decoding docs for permissions check")
+
 		return false
 	}
 

function/runtime.go

@@ -4,12 +4,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"log"
 	"net/http"
 	"strings"
 	"time"
 
 	"github.com/staticbackendhq/core/internal"
+	"github.com/staticbackendhq/core/logger"
 
 	"github.com/dop251/goja"
 )
@@ -22,6 +22,7 @@ type ExecutionEnvironment struct {
 	Data      internal.ExecData
 
 	CurrentRun internal.ExecHistory
+	log        *logger.Logger
 }
 
 type Result struct {
@@ -368,7 +369,6 @@ func (env *ExecutionEnvironment) complete(err error) {
 
 	//TODO: this needs to be regrouped and ran un batch
 	if err := env.DataStore.RanFunction(env.BaseName, env.Data.ID, env.CurrentRun); err != nil {
-		//TODO: do something with those error
-		log.Println("error logging function complete: ", err)
+		env.log.Error().Err(err).Msg("error logging function complete")
 	}
 }

function/scheduler.go

@@ -1,10 +1,10 @@
 package function
 
 import (
-	"log"
 	"time"
 
 	"github.com/staticbackendhq/core/internal"
+	"github.com/staticbackendhq/core/logger"
 
 	"github.com/go-co-op/gocron"
 	"go.mongodb.org/mongo-driver/mongo"
@@ -15,12 +15,13 @@ type TaskScheduler struct {
 	Volatile  internal.PubSuber
 	DataStore internal.Persister
 	Scheduler *gocron.Scheduler
+	log       *logger.Logger
 }
 
 func (ts *TaskScheduler) Start() {
 	tasks, err := ts.DataStore.ListTasks()
 	if err != nil {
-		log.Println("error loading tasks: ", err)
+		ts.log.Error().Err(err).Msg("error loading tasks")
 		return
 	}
 
@@ -30,7 +31,7 @@ func (ts *TaskScheduler) Start() {
 	for _, task := range tasks {
 		_, err := ts.Scheduler.Cron(task.Interval).Tag(task.ID).Do(ts.run, task)
 		if err != nil {
-			log.Printf("error scheduling this task: %s -> %v\n", task.ID, err)
+			ts.log.Error().Err(err).Msgf("error scheduling this task: %s", task.ID)
 		}
 	}
 }
@@ -41,7 +42,8 @@ func (ts *TaskScheduler) run(task internal.Task) {
 	if err := ts.Volatile.GetTyped("root:"+task.BaseName, &auth); err != nil {
 		tok, err := ts.DataStore.GetRootForBase(task.BaseName)
 		if err != nil {
-			log.Printf("error finding root token for base %s: %v\n", task.BaseName, err)
+			ts.log.Error().Err(err).Msgf("error finding root token for base %s", task.BaseName)
+
 			return
 		}
 
@@ -54,7 +56,7 @@ func (ts *TaskScheduler) run(task internal.Task) {
 		}
 
 		if err := ts.Volatile.SetTyped("root:"+task.BaseName, auth); err != nil {
-			log.Println("error setting auth inside TaskScheduler.run: ", err)
+			ts.log.Error().Err(err).Msg("error setting auth inside TaskScheduler.run")
 			return
 		}
 	}
@@ -70,7 +72,7 @@ func (ts *TaskScheduler) run(task internal.Task) {
 func (ts *TaskScheduler) execFunction(auth internal.Auth, task internal.Task) {
 	fn, err := ts.DataStore.GetFunctionForExecution(task.BaseName, task.Value)
 	if err != nil {
-		log.Printf("cannot find function %s on task %s", task.Value, task.ID)
+		ts.log.Error().Err(err).Msgf("cannot find function %s on task %s", task.Value)
 		return
 	}
 
@@ -80,10 +82,11 @@ func (ts *TaskScheduler) execFunction(auth internal.Auth, task internal.Task) {
 		DataStore: ts.DataStore,
 		Volatile:  ts.Volatile,
 		Data:      fn,
+		log:       ts.log,
 	}
 
 	if err := exe.Execute(task.Name); err != nil {
-		log.Printf("error executing function %s: %v", task.Value, err)
+		ts.log.Error().Err(err).Msgf("error executing function %s", task.Value)
 	}
 }
 
@@ -92,7 +95,7 @@ func (ts *TaskScheduler) sendMessage(auth internal.Auth, task internal.Task) {
 
 	meta, ok := task.Meta.(internal.MetaMessage)
 	if !ok {
-		log.Println("unable to get meta data for type MetaMessage for task: ", task.ID)
+		ts.log.Warn().Msgf("unable to get meta data for type MetaMessage for task: %d", task.ID)
 		return
 	}
 
@@ -105,6 +108,6 @@ func (ts *TaskScheduler) sendMessage(auth internal.Auth, task internal.Task) {
 	}
 
 	if err := ts.Volatile.Publish(msg); err != nil {
-		log.Println("error publishing message from task", task.ID, err)
+		ts.log.Error().Err(err).Msgf("error publishing message from task: %d", task.ID)
 	}
 }

function/subscriber.go

@@ -2,14 +2,15 @@ package function
 
 import (
 	"fmt"
-	"log"
 
 	"github.com/staticbackendhq/core/internal"
+	"github.com/staticbackendhq/core/logger"
 )
 
 type Subscriber struct {
 	PubSub     internal.PubSuber
 	GetExecEnv func(token string) (ExecutionEnvironment, error)
+	Log        *logger.Logger
 }
 
 // Start starts the system event subscription.
@@ -26,7 +27,7 @@ func (sub *Subscriber) Start() {
 		case msg := <-receiver:
 			go sub.process(msg)
 		case <-close:
-			log.Println("system event channel closed?!?")
+			sub.Log.Info().Msg("system event channel closed?!?")
 		}
 	}
 }
@@ -44,8 +45,7 @@ func (sub *Subscriber) process(msg internal.Command) {
 func (sub *Subscriber) handleRealtimeEvents(msg internal.Command) {
 	exe, err := sub.GetExecEnv(msg.Token)
 	if err != nil {
-		log.Println("cannot retrieve base from token", msg.Token)
-		log.Println(err)
+		sub.Log.Error().Err(err).Msgf("cannot retrieve base from token: %s", msg.Token)
 		return
 	}
 
@@ -55,13 +55,13 @@ func (sub *Subscriber) handleRealtimeEvents(msg internal.Command) {
 	if err := sub.PubSub.GetTyped(key, &ids); err != nil {
 		funcs, err := exe.DataStore.ListFunctionsByTrigger(exe.BaseName, msg.Type)
 		if err != nil {
-			log.Println("error getting functions by trigger: ", err)
+			sub.Log.Error().Err(err).Msg("error getting functions by trigger")
 			return
 		}
 
 		for _, fn := range funcs {
 			if err := sub.PubSub.SetTyped("fn_"+fn.ID, fn); err != nil {
-				log.Println("error adding function  to cache: ", err)
+				sub.Log.Error().Err(err).Msg("error adding function  to cache")
 				return
 			}
 
@@ -74,14 +74,14 @@ func (sub *Subscriber) handleRealtimeEvents(msg internal.Command) {
 	for _, id := range ids {
 		var fn internal.ExecData
 		if err := sub.PubSub.GetTyped("fn_"+id, &fn); err != nil {
-			log.Println("error getting function out of cache: ", err)
+			sub.Log.Error().Err(err).Msg("error getting function out of cache")
 			return
 		}
 
 		exe.Data = fn
 		go func(ex ExecutionEnvironment) {
 			if err := ex.Execute(msg); err != nil {
-				log.Printf(`executing "%s" function failed: %v"`, ex.Data.FunctionName, err)
+				sub.Log.Error().Err(err).Msgf(`executing "%s" function failed"`, ex.Data.FunctionName)
 			}
 		}(exe)
 	}

oauth.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/staticbackendhq/core/config"
 	"github.com/staticbackendhq/core/internal"
+	"github.com/staticbackendhq/core/logger"
 	"github.com/staticbackendhq/core/middleware"
 
 	"github.com/markbates/goth"
@@ -24,6 +25,7 @@ const (
 
 type ExternalLogins struct {
 	membership *membership
+	log        *logger.Logger
 }
 
 type ExternalUser struct {
@@ -185,7 +187,7 @@ func (el *ExternalLogins) callback() http.Handler {
 				return
 			}
 
-			render(w, r, "oauth.html", nil, nil)
+			render(w, r, "oauth.html", nil, nil, el.log)
 		})
 
 		next.ServeHTTP(w, r)