added console instance + log instance + log

Author: warstrolo

README.md

@@ -14,17 +14,17 @@ Database Log (Cassandra DB) => Soon (Q2 2022)
 
 ## Log format 
 
-**Product**-**Service**-**Location**-**Timestamp**-**FuncType**-**Type**-**Code**-**Message**
+**Product**-**Service**-**Location**-**Timestamp**-**FuncType**-**Level**-**Code**-**Message**
 
 **Product** must be an ID that refer to the product (a product have multiples services)
 
 **Service** must the an ID that refer to the impacted service (Like for instance a API gateway)
 
 **Location** must be where the error occured (like EU01, or could be more precise like EU01-DC1-R01-N01)
 
-**Timestamp** Is when the log was triggered
+**Timestamp** Is when the log was triggered (in milliseconds)
 
-**Type** `(verb,debug,info,warn,error,fatal)`
+**Level** `(verb,debug,info,warn,error,fatal)`
 
 **Code** Is an OPcode, for instance auth system = 03 so all the log that are from the auth system are code=03 
 

log/main.go

@@ -0,0 +1,77 @@
+package log
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+type FlagLevel string
+
+const (
+	FlagVerbose FlagLevel = "verb"
+	FlagDebug   FlagLevel = "debug"
+	FlagInfo    FlagLevel = "info"
+	FlagWarn    FlagLevel = "warn"
+	FlagError   FlagLevel = "error"
+	FlagFatal   FlagLevel = "fatal"
+	FlagNone    FlagLevel = "none"
+)
+
+type Log struct {
+	Product   string    `json:"product"`
+	Service   string    `json:"service"`
+	Location  string    `json:"location"`
+	Timestamp string    `json:"timestamp"`
+	Level     FlagLevel `json:"level"`
+	Code      string    `json:"code"`
+	Message   string    `json:"message"`
+}
+
+func CreateLog(product string, service string, location string, level FlagLevel, code string, message string) *Log {
+	return &Log{
+		Product:   product,
+		Service:   service,
+		Location:  location,
+		Timestamp: fmt.Sprint(time.Now().UnixMilli()),
+		Level:     level,
+		Code:      code,
+		Message:   message,
+	}
+}
+
+func (log *Log) ToJSONString() (string, error) {
+	b, err := json.Marshal(log)
+	return string(b), err
+}
+
+// type FlagCompareOp int
+
+// const (
+// 	FlagL FlagCompareOp = iota
+// 	FlagLEQ
+// 	FlagEQ
+// 	FlagMEQ
+// 	FlagM
+// )
+
+func FlagCompareOneMoreThanTwo(one FlagLevel, two FlagLevel) bool {
+	switch one {
+	case FlagVerbose:
+		return false
+	case FlagDebug:
+		return (two != FlagVerbose)
+	case FlagInfo:
+		return (two != FlagVerbose && two != FlagDebug)
+	case FlagWarn:
+		return (two != FlagVerbose && two != FlagDebug && two != FlagInfo)
+	case FlagError:
+		return (two != FlagVerbose && two != FlagDebug && two != FlagInfo && two != FlagWarn)
+	case FlagFatal:
+		return (two != FlagVerbose && two != FlagDebug && two != FlagInfo && two != FlagWarn && two != FlagError)
+	case FlagNone:
+		return true
+	default:
+		return false
+	}
+}

loginstance/docs.go

@@ -0,0 +1,2 @@
+// This package manage the logger instance
+package log

loginstance/main.go

@@ -0,0 +1,27 @@
+package log
+
+import (
+	"github.com/meduvia/godolog/log"
+	"github.com/meduvia/godolog/writer"
+)
+
+type LogInstance struct {
+	writer *writer.WriterInstance
+	level log.FlagLevel
+}
+
+func NewLogInstance(logbackend *writer.WriterInstance, level log.FlagLevel) *LogInstance{
+	return &LogInstance{
+		writer: logbackend,
+		level: level,
+	}
+}
+
+func (logger *LogInstance) Log(product string, service string, location string, level log.FlagLevel, code string, message string) error {
+	if (log.FlagCompareOneMoreThanTwo(logger.level, level)) {
+		return nil // break log level requirement is more than log level
+	}
+	logobj := log.CreateLog(product, service, location, level,code, message)
+	return (*logger.writer).Write(logobj)
+}
+

writer/console.go

@@ -0,0 +1,42 @@
+package writer
+
+import "github.com/meduvia/godolog/log"
+
+type ConsoleWriterInterface interface {
+	// we did not add verbose because in major logger backend verbose does not exist
+	Debug(string) // verbose + debug
+	Info(string)  // info
+	Warn(string)  // warn
+	Error(string) // error + fatal
+	// We did not add fatal to prevent logger backend from killing the running program
+}
+
+type ConsoleWriter struct {
+	writer *ConsoleWriterInterface
+}
+
+func NewConsoleWriter(LogBackend *ConsoleWriterInterface) *ConsoleWriter {
+	return &ConsoleWriter{
+		writer: LogBackend,
+	}
+} 
+
+func (consolewriter *ConsoleWriter) Write(logobj *log.Log) {
+	logstring, err := logobj.ToJSONString()
+	if err != nil {
+		(*consolewriter.writer).Error("Error Writing log")
+	}
+	switch logobj.Level {
+	case log.FlagVerbose, log.FlagDebug:
+		(*consolewriter.writer).Debug(logstring)
+	case log.FlagInfo:
+		(*consolewriter.writer).Info(logstring)
+	case log.FlagWarn:
+		(*consolewriter.writer).Warn(logstring)
+	case log.FlagError, log.FlagFatal:
+		(*consolewriter.writer).Error(logstring)
+	default:
+		(*consolewriter.writer).Debug(logstring)
+	}
+
+}

writer/file.go

@@ -0,0 +1,2 @@
+package writer
+

writer/main.go

@@ -0,0 +1,8 @@
+package writer
+
+import "github.com/meduvia/godolog/log"
+
+type WriterInstance interface {
+	Write(*log.Log) error
+}
+