Create a logging policy using sync/atomic load and store value

back/cmd/openbsrv/httpsrv.go

@@ -1,8 +1,9 @@
 package main
 
 import (
- "github.com/OpenEugene/openboard/back/internal/httpsrv"
  "github.com/codemodus/hedrs"
+
+ "github.com/OpenEugene/openboard/back/internal/httpsrv"
 )
 
 type httpSrv struct {

back/cmd/openbsrv/main.go

@@ -7,6 +7,9 @@ import (
  "path"
 
  "github.com/codemodus/sigmon/v2"
+
+ "github.com/OpenEugene/openboard/back/internal/dbg"
+ "github.com/OpenEugene/openboard/back/internal/log"
 )
 
 func main() {
@@ -28,6 +31,7 @@ func run() error {
  migrate bool
  rollback bool
  skipsrv bool
+ debug bool
  frontDir = "../../../front/public"
  migTblPfx = "mig_"
  )
@@ -40,13 +44,31 @@ func run() error {
  flag.BoolVar(&migrate, "migrate", migrate, "migrate up")
  flag.BoolVar(&rollback, "rollback", rollback, "migrate dn")
  flag.BoolVar(&skipsrv, "skipsrv", skipsrv, "skip server run")
+ flag.BoolVar(&debug, "debug", debug, "debug true or false")
  flag.StringVar(&frontDir, "frontdir", frontDir, "front public assets directory")
  flag.Parse()
 
  sm := sigmon.New(nil)
  sm.Start()
  defer sm.Stop()
 
+ logCfg := log.Config{
+ Err: log.Output{
+ Out: os.Stdout,
+ Prefix: "[ERROR] ",
+ },
+ Inf: log.Output{
+ Out: os.Stdout,
+ Prefix: "[INFO] ",
+ },
+ }
+ log := log.New(logCfg)
+
+ if debug {
+ dbg.SetOut(os.Stdout)
+ }
+
+ dbg.Logf("set up SQL database at %s:%s.", dbaddr, dbport)
  db, err := newSQLDB(dbdrvr, dbCreds(dbname, dbuser, dbpass, dbaddr, dbport))
  if err != nil {
  return err
@@ -67,7 +89,7 @@ func run() error {
  if mres.HasError() {
  return mres.ErrsErr()
  }
- fmt.Println(migType+":", mres)
+ log.Info("%s: %s", migType, mres)
  }
 
  if skipsrv {
@@ -93,7 +115,7 @@ func run() error {
  }
  })
 
- fmt.Println("to gracefully stop the application, send signal like TERM (CTRL-C) or HUP")
+ log.Info("to gracefully stop the application, send signal like TERM (CTRL-C) or HUP")
 
  return m.serve()
 }

back/internal/authsvc/authsvc.go

@@ -3,8 +3,9 @@ package authsvc
 import (
  "context"
 
- "github.com/OpenEugene/openboard/back/internal/pb"
  "google.golang.org/grpc"
+
+ "github.com/OpenEugene/openboard/back/internal/pb"
 )
 
 var _ pb.AuthServer = &AuthSvc{}
@@ -30,7 +31,6 @@ func (s *AuthSvc) RegisterWithGRPCServer(g *grpc.Server) error {
 // AddAuth implements part of the pb.AuthServer interface.
 func (s *AuthSvc) AddAuth(ctx context.Context, req *pb.AddAuthReq) (*pb.AuthResp, error) {
  // TODO: implement AddAuth
-
  return nil, nil
 }
 

back/internal/dbg/dbg.go

@@ -0,0 +1,64 @@
+// Package dbg allows for outputting information that can help with debugging
+// the application.
+package dbg
+
+import (
+ "io"
+ "log"
+ "sync/atomic"
+)
+
+// dbg is thread-safe.
+type dbg struct {
+ atomVal atomic.Value
+}
+
+func new() *dbg {
+ var d dbg
+ var logr *log.Logger
+ d.atomVal.Store(logr)
+ return &d
+}
+
+func (d *dbg) logln(as ...interface{}) {
+ logr := d.atomVal.Load().(*log.Logger)
+ if logr != nil {
+ logr.Println(as...)
+ }
+}
+
+func (d *dbg) logf(format string, as ...interface{}) {
+ logr := d.atomVal.Load().(*log.Logger)
+ if logr != nil {
+ logr.Printf(format+"\n", as...)
+ }
+}
+
+func (d *dbg) setOut(out io.Writer) {
+ var logr *log.Logger
+
+ if out != nil {
+ logr = log.New(out, "", 0)
+ d.atomVal.Store(logr)
+ return
+ }
+
+ d.atomVal.Store(logr)
+}
+
+var debug = new()
+
+// Log outputs information to help with application debugging.
+func Log(as ...interface{}) {
+ debug.logln(as...)
+}
+
+// Logf outputs debugging information and is able to interpret formatting verbs.
+func Logf(format string, as ...interface{}) {
+ debug.logf(format, as...)
+}
+
+// SetDebugOut allows for choosing where debug information will be written to.
+func SetOut(out io.Writer) {
+ debug.setOut(out)
+}

back/internal/dbg/dbg_test.go

@@ -0,0 +1,74 @@
+package dbg
+
+import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "testing"
+)
+
+func BenchmarkDbgUse(b *testing.B) {
+ SetOut(ioutil.Discard)
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ Log("")
+ }
+ })
+}
+func BenchmarkDbgUseNil(b *testing.B) {
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ Log("")
+ }
+ })
+}
+func BenchmarkDbgSetAndUse(b *testing.B) {
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ SetOut(ioutil.Discard)
+ Log("")
+ }
+ })
+}
+func BenchmarkDbgSetAndUseNil(b *testing.B) {
+ b.RunParallel(func(pb *testing.PB) {
+ for pb.Next() {
+ SetOut(nil)
+ Log("")
+ }
+ })
+}
+
+func TestSetOut(t *testing.T) {
+ Log("debug not set")
+
+ buff := bytes.NewBuffer([]byte{})
+ SetOut(buff)
+ msg := "debug set to bytes buffer"
+ Log(msg)
+ got := buff.String()
+
+ want := msg + "\n"
+ if got != want {
+ t.Errorf("want: %s, got: %s", want, got)
+ }
+
+ SetOut(nil)
+ buff.Reset()
+ want = ""
+ Log("debug set to nil")
+ got = buff.String()
+ if got != want {
+ t.Errorf("want: nothing, got: %s", got)
+ }
+
+ SetOut(buff)
+ buff.Reset()
+ msg = "debug set to bytes buffer, %s time"
+ Logf(msg, "second")
+ got = buff.String()
+ want = fmt.Sprintf(msg+"\n", "second")
+ if got != want {
+ t.Errorf("want: %s, got: %s", want, got)
+ }
+}

back/internal/log/log.go

@@ -0,0 +1,45 @@
+// Package log allows for outputting information regarding application errors
+// and events important to know for proper operation.
+package log
+
+import (
+ "io"
+ "log"
+)
+
+// Output is where logger will write to. Prefix is what will precede log text.
+type Output struct {
+ Out io.Writer
+ Prefix string
+}
+
+// Config allows for configuring the logger outputs for errors and information
+// type log messages.
+type Config struct {
+ Err Output
+ Inf Output
+}
+
+// Log is able to write information to a chosen output.
+type Log struct {
+ err *log.Logger
+ inf *log.Logger
+}
+
+// New provides a pointer to a new instance of the Log object.
+func New(c Config) *Log {
+ return &Log{
+ inf: log.New(c.Inf.Out, c.Inf.Prefix, 0),
+ err: log.New(c.Err.Out, c.Err.Prefix, 0),
+ }
+}
+
+// Info outputs information from the application.
+func (log *Log) Info(format string, as ...interface{}) {
+ log.inf.Printf(format+"\n", as...)
+}
+
+// Error outputs error information from the application.
+func (log *Log) Error(format string, as ...interface{}) {
+ log.err.Printf(format+"\n", as...)
+}

back/internal/postsvc/postsvc.go

@@ -4,10 +4,11 @@ import (
  "context"
  "database/sql"
 
+ "google.golang.org/grpc"
+
  "github.com/OpenEugene/openboard/back/internal/pb"
  "github.com/OpenEugene/openboard/back/internal/postsvc/internal/postdb"
  "github.com/OpenEugene/openboard/back/internal/postsvc/internal/postdb/mysqlmig"
- "google.golang.org/grpc"
 )
 
 var _ pb.PostServer = &PostSvc{}