Merge pull request #11 from ethanholz/log-parity

feat: Updated to include print and added ln variants for all logs

README.md

@@ -0,0 +1,15 @@
+log-socket
+==========
+`log-socket` is a drop-in replacement for Go's `log` package that allows for streaming of logs via WebSockets.
+
+## Installation
+To install the library:
+`go get github.com/taigrr/log-socket`
+
+## Running
+To run a demo of this library:
+`go run main.go`
+
+This demo will do a sample of every log type and push results to `0.0.0.0:8080`. Once running, you can open a browser and navigate to 
+`0.0.0.0:8080` to see an example implementation of how logs are streamed.
+

log/log.go

@@ -1,4 +1,4 @@
-package logger
+package log
 
 import (
 	"errors"
@@ -147,6 +147,19 @@ func Tracef(format string, args ...interface{}) {
 	createLog(e)
 }
 
+// Trace prints out logs on trace level with newline
+func Traceln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(2),
+		Level:     "TRACE",
+		level:     LTrace,
+	}
+	createLog(e)
+}
+
 // Debug prints out logs on debug level
 func Debug(args ...interface{}) {
 	output := fmt.Sprint(args...)
@@ -173,6 +186,19 @@ func Debugf(format string, args ...interface{}) {
 	createLog(e)
 }
 
+// Debug prints out logs on debug level with a newline
+func Debugln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(2),
+		Level:     "DEBUG",
+		level:     LDebug,
+	}
+	createLog(e)
+}
+
 // Info prints out logs on info level
 func Info(args ...interface{}) {
 	output := fmt.Sprint(args...)
@@ -199,8 +225,21 @@ func Infof(format string, args ...interface{}) {
 	createLog(e)
 }
 
+// Info prints out logs on info level with a newline
+func Infoln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(2),
+		Level:     "INFO",
+		level:     LInfo,
+	}
+	createLog(e)
+}
+
 // Info prints out logs on info level
-func Noticef(args ...interface{}) {
+func Notice(args ...interface{}) {
 	output := fmt.Sprint(args...)
 	e := Entry{
 		Timestamp: time.Now(),
@@ -225,6 +264,19 @@ func Noticef(format string, args ...interface{}) {
 	createLog(e)
 }
 
+// Info prints out logs on info level with a newline
+func Noticeln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(2),
+		Level:     "NOTICE",
+		level:     LNotice,
+	}
+	createLog(e)
+}
+
 // Warn prints out logs on warn level
 func Warn(args ...interface{}) {
 	output := fmt.Sprint(args...)
@@ -251,6 +303,19 @@ func Warnf(format string, args ...interface{}) {
 	createLog(e)
 }
 
+// Newline print for Warn
+func Warnln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(2),
+		Level:     "WARN",
+		level:     LWarn,
+	}
+	createLog(e)
+}
+
 // Error prints out logs on error level
 func Error(args ...interface{}) {
 	output := fmt.Sprint(args...)
@@ -277,6 +342,19 @@ func Errorf(format string, args ...interface{}) {
 	createLog(e)
 }
 
+// Error prints out logs on error level with a newline
+func Errorln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(2),
+		Level:     "ERROR",
+		level:     LError,
+	}
+	createLog(e)
+}
+
 // Panic prints out logs on panic level
 func Panic(args ...interface{}) {
 	output := fmt.Sprint(args...)
@@ -323,6 +401,28 @@ func Panicf(format string, args ...interface{}) {
 	panic(errors.New(output))
 }
 
+func Panicln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(2),
+		Level:     "PANIC",
+		level:     LPanic,
+	}
+	createLog(e)
+	if len(args) >= 0 {
+		switch args[0].(type) {
+		case error:
+			panic(args[0])
+		default:
+			// falls through to default below
+		}
+	}
+	Flush()
+	panic(errors.New(output))
+}
+
 // Fatal prints out logs on fatal level
 func Fatal(args ...interface{}) {
 	output := fmt.Sprint(args...)
@@ -353,6 +453,32 @@ func Fatalf(format string, args ...interface{}) {
 	os.Exit(1)
 }
 
+func Fatalln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(2),
+		Level:     "FATAL",
+		level:     LFatal,
+	}
+	createLog(e)
+	Flush()
+	os.Exit(1)
+}
+
+func Print(args ...interface{}) {
+	Info(args...)
+}
+
+func Printf(format string, args ...interface{}) {
+	Infof(format, args...)
+}
+
+func Println(args ...interface{}) {
+	Infoln(args...)
+}
+
 // fileInfo for getting which line in which file
 func fileInfo(skip int) string {
 	_, file, line, ok := runtime.Caller(skip)

log/log_test.go

@@ -1,4 +1,4 @@
-package logger
+package log
 
 import (
 	"strconv"
@@ -86,6 +86,15 @@ func TestInfo(t *testing.T) {
 	//	}
 }
 
+// Print prints out logs on info level
+func TestPrint(t *testing.T) {
+	//	if logLevel >= LInfo {
+	//		entry := logger.WithFields(logrus.Fields{})
+	//		entry.Data["file"] = fileInfo(2)
+	//		entry.Info(args...)
+	//	}
+}
+
 // Warn prints out logs on warn level
 func TestWarn(t *testing.T) {
 	//	if logLevel >= LWarn {
@@ -121,6 +130,7 @@ func TestPanic(t *testing.T) {
 	//		entry.Panic(args...)
 	//	}
 }
+
 func TestFlush(t *testing.T) {
 	defer Flush()
 }

log/logger.go

@@ -0,0 +1,362 @@
+package log
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"time"
+)
+
+func (l *Logger) SetInfoDepth(depth int) {
+	l.FileInfoDepth = depth
+}
+
+// Trace prints out logs on trace level
+func (l Logger) Trace(args ...interface{}) {
+	output := fmt.Sprint(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "TRACE",
+		level:     LTrace,
+	}
+	createLog(e)
+}
+
+// Formatted print for Trace
+func (l Logger) Tracef(format string, args ...interface{}) {
+	output := fmt.Sprintf(format, args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "TRACE",
+		level:     LTrace,
+	}
+	createLog(e)
+}
+
+// Trace prints out logs on trace level with newline
+func (l Logger) Traceln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "TRACE",
+		level:     LTrace,
+	}
+	createLog(e)
+}
+
+// Debug prints out logs on debug level
+func (l Logger) Debug(args ...interface{}) {
+	output := fmt.Sprint(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "DEBUG",
+		level:     LDebug,
+	}
+	createLog(e)
+}
+
+// Formatted print for Debug
+func (l Logger) Debugf(format string, args ...interface{}) {
+	output := fmt.Sprintf(format, args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "DEBUG",
+		level:     LDebug,
+	}
+	createLog(e)
+}
+
+// Info prints out logs on info level
+func (l Logger) Info(args ...interface{}) {
+	output := fmt.Sprint(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "INFO",
+		level:     LInfo,
+	}
+	createLog(e)
+}
+
+// Formatted print for Info
+func (l Logger) Infof(format string, args ...interface{}) {
+	output := fmt.Sprintf(format, args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "INFO",
+		level:     LInfo,
+	}
+	createLog(e)
+}
+
+// Info prints out logs on info level with newline
+func (l Logger) Infoln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "INFO",
+		level:     LInfo,
+	}
+	createLog(e)
+}
+
+// Notice prints out logs on notice level
+func (l Logger) Notice(args ...interface{}) {
+	output := fmt.Sprint(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "NOTICE",
+		level:     LNotice,
+	}
+	createLog(e)
+}
+
+// Formatted print for Notice
+func (l Logger) Noticef(format string, args ...interface{}) {
+	output := fmt.Sprintf(format, args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "NOTICE",
+		level:     LNotice,
+	}
+	createLog(e)
+}
+
+// Notice prints out logs on notice level with newline
+func (l Logger) Noticeln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "NOTICE",
+		level:     LNotice,
+	}
+	createLog(e)
+}
+
+// Warn prints out logs on warn level
+func (l Logger) Warn(args ...interface{}) {
+	output := fmt.Sprint(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "WARN",
+		level:     LWarn,
+	}
+	createLog(e)
+}
+
+// Formatted print for Warn
+func (l Logger) Warnf(format string, args ...interface{}) {
+	output := fmt.Sprintf(format, args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "WARN",
+		level:     LWarn,
+	}
+	createLog(e)
+}
+
+// Warn prints out logs on warn level with a newline
+func (l Logger) Warnln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "WARN",
+		level:     LWarn,
+	}
+	createLog(e)
+}
+
+// Error prints out logs on error level
+func (l Logger) Error(args ...interface{}) {
+	output := fmt.Sprint(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "ERROR",
+		level:     LError,
+	}
+	createLog(e)
+}
+
+// Formatted print for error
+func (l Logger) Errorf(format string, args ...interface{}) {
+	output := fmt.Sprintf(format, args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "ERROR",
+		level:     LError,
+	}
+	createLog(e)
+}
+
+// Error prints out logs on error level with a new line
+func (l Logger) Errorln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "ERROR",
+		level:     LError,
+	}
+	createLog(e)
+}
+
+// Panic prints out logs on panic level
+func (l Logger) Panic(args ...interface{}) {
+	output := fmt.Sprint(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "PANIC",
+		level:     LPanic,
+	}
+	createLog(e)
+	if len(args) >= 0 {
+		switch args[0].(type) {
+		case error:
+			panic(args[0])
+		default:
+			// falls through to default below
+		}
+	}
+	Flush()
+	panic(errors.New(output))
+}
+
+// Formatted print for panic
+func (l Logger) Panicf(format string, args ...interface{}) {
+	output := fmt.Sprintf(format, args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "PANIC",
+		level:     LPanic,
+	}
+	createLog(e)
+	if len(args) >= 0 {
+		switch args[0].(type) {
+		case error:
+			panic(args[0])
+		default:
+			// falls through to default below
+		}
+	}
+	Flush()
+	panic(errors.New(output))
+}
+
+// Panic prints out logs on panic level with a newline
+func (l Logger) Panicln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "PANIC",
+		level:     LPanic,
+	}
+	createLog(e)
+	if len(args) >= 0 {
+		switch args[0].(type) {
+		case error:
+			panic(args[0])
+		default:
+			// falls through to default below
+		}
+	}
+	Flush()
+	panic(errors.New(output))
+}
+
+// Fatal prints out logs on fatal level
+func (l Logger) Fatal(args ...interface{}) {
+	output := fmt.Sprint(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "FATAL",
+		level:     LFatal,
+	}
+	createLog(e)
+	Flush()
+	os.Exit(1)
+}
+
+// Formatted print for fatal
+func (l Logger) Fatalf(format string, args ...interface{}) {
+	output := fmt.Sprintf(format, args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "FATAL",
+		level:     LFatal,
+	}
+	createLog(e)
+	Flush()
+	os.Exit(1)
+}
+
+// Fatal prints fatal level with a new line
+func (l Logger) Fatalln(args ...interface{}) {
+	output := fmt.Sprintln(args...)
+	e := Entry{
+		Timestamp: time.Now(),
+		Output:    output,
+		File:      fileInfo(l.FileInfoDepth),
+		Level:     "FATAL",
+		level:     LFatal,
+	}
+	createLog(e)
+	Flush()
+	os.Exit(1)
+}
+
+// Handles print to info
+func (l Logger) Print(args ...interface{}) {
+	l.Info(args...)
+}
+
+// Handles formatted print to info
+func (l Logger) Printf(format string, args ...interface{}) {
+	l.Infof(format, args...)
+}
+
+// Handles print to info with new line
+func (l Logger) Println(args ...interface{}) {
+	l.Infoln(args...)
+}

log/types.go

@@ -1,4 +1,4 @@
-package logger
+package log
 
 import "time"
 
@@ -29,3 +29,7 @@ type Entry struct {
 	Level     string    `json:"level"`
 	level     Level
 }
+
+type Logger struct {
+	FileInfoDepth int
+}

main.go

@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"github.com/taigrr/log-socket/browser"
-	"github.com/taigrr/log-socket/logger"
+	logger "github.com/taigrr/log-socket/log"
 	"github.com/taigrr/log-socket/ws"
 )
 

ws/server.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 
 	"github.com/gorilla/websocket"
-	"github.com/taigrr/log-socket/logger"
+	logger "github.com/taigrr/log-socket/log"
 )
 
 // var addr = flag.String("addr", "localhost:8080", "http service address")