Merge pull request #11 from ethanholz/log-parity

feat: Updated to include print and added ln variants for all logs
2025-01-18 04:53:14 -08:00 · 2022-10-13 08:05:39 -07:00 · 2022-10-13 09:59:04 -05:00 · 2022-10-10 13:38:59 -07:00 · 2022-10-10 12:16:52 -05:00 · 2022-10-10 12:09:29 -05:00
12 changed files with 1148 additions and 454 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,12 @@
 # These are supported funding model platforms
 github: taigrr # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
 patreon: # Replace with a single Patreon username
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username
 tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 liberapay: # Replace with a single Liberapay username
 issuehunt: # Replace with a single IssueHunt username
 otechie: # Replace with a single Otechie username
 custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
--- a/12
+++ b/12
@@ -0,0 +1,12 @@
 Copyright (C) 2019-2021 by Tai Groot <tai@taigrr.com>
 Permission to use, copy, modify, and/or distribute this software for any
 purpose with or without fee is hereby granted.
 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
--- a/README.md
+++ b/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.
--- a/browser/browser.go
+++ b/browser/browser.go
@@ -0,0 +1,217 @@
 package browser
 import (
 	"html/template"
 	"net/http"
 	"strings"
 )
 func LogSocketViewHandler(w http.ResponseWriter, r *http.Request) {
 	wsResource := r.Host + r.URL.Path
 	if r.TLS != nil {
 		wsResource = "wss://" + wsResource
 	} else {
 		wsResource = "ws://" + wsResource
 	}
 	wsResource = strings.TrimSuffix(wsResource, "/") + "/ws"
 	homeTemplate.Execute(w, wsResource)
 }
 var homeTemplate = template.Must(template.New("").Parse(`
 <!DOCTYPE html>
 <html>
 <head>
 <meta charset="utf-8">
 </head>
 <body>
 <center>
 <input type="text" id="search" onkeyup="filterTable()" placeholder="Filter...">
 <input type="checkbox" id="shouldScroll" checked>Enable Autoscroll<br>
 <table id="logHeaders" style="text-align:left; width:80%;" >
 <tbody>
 <tr class="header">
 <th style="width:20%;">TimeStamp</th>
 <th style="width:5%;">Level</th>
 <th style="width:65%;">Output</th>
 <th style="width:10%;">Source</th>
 </tr>
 </tbody>
 </table>
 <div id="tableWrapper">
 <table id="logs" style="text-align:left; width:100%;" >
 <tbody id="tbodylogs">
 <tr class="header">
 <th style="width:20%;"></th>
 <th style="width:5%;"></th>
 <th style="width:65%;"></th>
 <th style="width:10%;"></th>
 </tr>
 </tbody>
 </table>
 </div>
 <br>
 <input class="button" type="button" id="download" value="Download Logs" style="background-color:#3f51b5;"/>
 <input class="button" type="button" id="delete" value="Delete Logs" style="background-color:#f44336"/>
 </center>
 </body>
 <footer>
 <style>
 #tableWrapper{
 	overflow-y: scroll;
 	display: flow-root;
 	width: 80%;
 	height: 80vh;
 }
 td,tr{
 	height: min-content;
 }
 .button{
 	display: inline-block;
 	width: 5vw;
 	height: 5vh;
 }
 </style>
 <script>  
 var logTable = document.getElementById("logs");
 var logTableB = document.getElementById("tbodylogs");
 var ws = null;
 var application = "demo-commit"
 var logs = [];
 function sleep(ms) {
 	return new Promise(resolve => setTimeout(resolve, ms));
 }
 function download(filename, text) {
 	var element = document.createElement('a');
 	element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text));
 	element.setAttribute('download', filename);
 	element.style.display = 'none';
 	document.body.appendChild(element);
 	element.click();
 	document.body.removeChild(element);
 }
 function openSocket() {
 	if (ws) {
 		return false;
 	}
 	ws = new WebSocket("{{.}}");
 	ws.onclose = async function(evt) {
 		ws = null;
 		while(ws == null){
 			openSocket()
 			await sleep(5000);
 		}
 	}
 	ws.onmessage = function(evt) {
 		var entry = JSON.parse(evt.data)
 		logs.push(entry)
 		var row = document.createElement('tr');
 		var ts = document.createElement('td');
 		var tst = document.createTextNode(entry.timestamp);
 		ts.appendChild(tst);
 		row.appendChild(ts);
 		var ts = document.createElement('td');
 		var tst = document.createTextNode(entry.level);
 		ts.appendChild(tst);
 		row.appendChild(ts);
 		var ts = document.createElement('td');
 		var tst = document.createTextNode(entry.output);
 		ts.appendChild(tst);
 		row.appendChild(ts);
 		var ts = document.createElement('td');
 		var tst = document.createTextNode(entry.file);
 		ts.appendChild(tst);
 		row.appendChild(ts);
 		var bg="";
 		switch(entry.level){
 		case "INFO":
 			bg="white";
 			break;
 		case "ERROR":
 			bg="#f44336";
 			break;
 		case "WARN":
 			bg="#fb8c00"
 			break;
 		case "TRACE":
 			bg="#E1F5FE"
 			break;
 		case "DEBUG":
 			bg="#B3E5FC"
 			break;
 		default:
 			bg="white"
 			break;
 		}
 		row.style.backgroundColor=bg
 		logTableB.append(row)
 		filterTable()
 	}
 	ws.onerror = function(evt) {
 		if (evt != null && evt.data != null){
 			// handle error here
 		}
 	}
 }
 function clearTable(){
 	if(!window.confirm("Are you sure you want to delete all logs?")){
 		return
 	}
 	logs = []
 	while (logTableB.childNodes.length > 1) {
 		logTableB.removeChild(logTableB.childNodes[1]);
 	}
 }
 function filterTable() {
 	var cols, input, filter, table, tr, td, i, txtValue, w;
 	input = document.getElementById("search");
 	filter = input.value;
 	table = logTableB;
 	tr = table.getElementsByTagName("tr");
 	for (i = 1; i < tr.length; i++) {
 		cols = tr[i].getElementsByTagName("td");
 		var visible = false;
 		for (w = 0; w < cols.length; w++){
 			if (!visible && cols[w]) {
 				td = cols[w]
 				txtValue = td.textContent || td.innerText;
 				if (txtValue.indexOf(filter) > -1) {
 					visible = true
 				} 
 			}
 		}
 		if(visible){
 			tr[i].style.display = "";
 		} else {
 			tr[i].style.display = "none";
 		}
 	}
 }
 function pageScroll() {
 	if (document.getElementById('shouldScroll').checked) {
 		document.getElementById('tableWrapper').scrollBy(0,10);
 	}
 	setTimeout(pageScroll,10);
 }
 document.getElementById("delete").addEventListener("click", function(){
 	clearTable()
 }, false);
 document.getElementById("download").addEventListener("click", function(){
 	download(application+'.json',JSON.stringify(logs));
 }, false);
 openSocket();
 pageScroll();
 </script>
 </footer>
 </html>
 `))
--- a/go.mod
+++ b/go.mod
@@ -1,5 +1,5 @@
 module github.com/taigrr/log-socket
-go 1.16
+go 1.17
 require github.com/gorilla/websocket v1.4.2
--- a/log/log.go
+++ b/log/log.go
@@ -0,0 +1,495 @@
 package log
 import (
 	"errors"
 	"fmt"
 	"os"
 	"runtime"
 	"strings"
 	"sync"
 	"time"
 )
 var (
 	clients        []*Client
 	sliceTex       sync.Mutex
 	stderrClient   *Client
 	cleanup        sync.Once
 	stderrFinished chan bool
 )
 func init() {
 	stderrClient = CreateClient()
 	stderrClient.SetLogLevel(LTrace)
 	stderrFinished = make(chan bool, 1)
 	go stderrClient.logStdErr()
 }
 func (c *Client) logStdErr() {
 	for {
 		select {
 		case e, more := <-c.writer:
 			if e.level >= c.LogLevel {
 				fmt.Fprintf(os.Stderr, "%s\t%s\t%s\t%s\n", e.Timestamp.String(), e.Level, e.Output, e.File)
 			}
 			if !more {
 				stderrFinished <- true
 				return
 			}
 		}
 	}
 }
 func CreateClient() *Client {
 	var client Client
 	client.initialized = true
 	client.writer = make(LogWriter, 1000)
 	sliceTex.Lock()
 	clients = append(clients, &client)
 	sliceTex.Unlock()
 	return &client
 }
 func Flush() {
 	cleanup.Do(func() {
 		close(stderrClient.writer)
 		<-stderrFinished
 		stderrClient.Destroy()
 	})
 }
 func (c *Client) Destroy() error {
 	var otherClients []*Client
 	if !c.initialized {
 		panic(errors.New("Cannot delete uninitialized client, did you use CreateClient?"))
 	}
 	sliceTex.Lock()
 	c.writer = nil
 	c.initialized = false
 	for _, x := range clients {
 		if x.initialized {
 			otherClients = append(otherClients, x)
 		}
 	}
 	clients = otherClients
 	sliceTex.Unlock()
 	return nil
 }
 func (c *Client) GetLogLevel() Level {
 	if !c.initialized {
 		panic(errors.New("Cannot get level for uninitialized client, use CreateClient instead"))
 	}
 	return c.LogLevel
 }
 func createLog(e Entry) {
 	sliceTex.Lock()
 	for _, c := range clients {
 		func(c *Client, e Entry) {
 			select {
 			case c.writer <- e:
 				// try to clear out one of the older entries
 			default:
 				select {
 				case <-c.writer:
 					c.writer <- e
 				default:
 				}
 			}
 		}(c, e)
 	}
 	sliceTex.Unlock()
 }
 func SetLogLevel(level Level) {
 	stderrClient.LogLevel = level
 }
 // SetLogLevel set log level of logger
 func (c *Client) SetLogLevel(level Level) {
 	if !c.initialized {
 		panic(errors.New("Cannot set level for uninitialized client, use CreateClient instead"))
 	}
 	c.LogLevel = level
 }
 func (c *Client) Get() Entry {
 	if !c.initialized {
 		panic(errors.New("Cannot get logs for uninitialized client, did you use CreateClient?"))
 	}
 	return <-c.writer
 }
 // Trace prints out logs on trace level
 func Trace(args ...interface{}) {
 	output := fmt.Sprint(args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "TRACE",
 		level:     LTrace,
 	}
 	createLog(e)
 }
 // Formatted print for Trace
 func Tracef(format string, args ...interface{}) {
 	output := fmt.Sprintf(format, args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "TRACE",
 		level:     LTrace,
 	}
 	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...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "DEBUG",
 		level:     LDebug,
 	}
 	createLog(e)
 }
 // Formatted print for Debug
 func Debugf(format string, args ...interface{}) {
 	output := fmt.Sprintf(format, args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "DEBUG",
 		level:     LDebug,
 	}
 	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...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "INFO",
 		level:     LInfo,
 	}
 	createLog(e)
 }
 // Formatted print for Info
 func Infof(format string, args ...interface{}) {
 	output := fmt.Sprintf(format, args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "INFO",
 		level:     LInfo,
 	}
 	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 Notice(args ...interface{}) {
 	output := fmt.Sprint(args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "NOTICE",
 		level:     LNotice,
 	}
 	createLog(e)
 }
 // Formatted print for Info
 func Noticef(format string, args ...interface{}) {
 	output := fmt.Sprintf(format, args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "NOTICE",
 		level:     LNotice,
 	}
 	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...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "WARN",
 		level:     LWarn,
 	}
 	createLog(e)
 }
 // Formatted print for Warn
 func Warnf(format string, args ...interface{}) {
 	output := fmt.Sprintf(format, args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "WARN",
 		level:     LWarn,
 	}
 	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...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "ERROR",
 		level:     LError,
 	}
 	createLog(e)
 }
 // Formatted print for error
 func Errorf(format string, args ...interface{}) {
 	output := fmt.Sprintf(format, args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "ERROR",
 		level:     LError,
 	}
 	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...)
 	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))
 }
 // Formatted print for panic
 func Panicf(format string, args ...interface{}) {
 	output := fmt.Sprintf(format, 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))
 }
 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...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "FATAL",
 		level:     LFatal,
 	}
 	createLog(e)
 	Flush()
 	os.Exit(1)
 }
 // Formatted print for fatal
 func Fatalf(format string, args ...interface{}) {
 	output := fmt.Sprintf(format, args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "FATAL",
 		level:     LFatal,
 	}
 	createLog(e)
 	Flush()
 	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)
 	if !ok {
 		file = "<???>"
 		line = 1
 	} else {
 		slash := strings.LastIndex(file, "/")
 		if slash >= 0 {
 			file = file[slash+1:]
 		}
 	}
 	return fmt.Sprintf("%s:%d", file, line)
 }
--- a/logger/logger_test.go
+++ b/logger/logger_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()
 }
--- a/log/logger.go
+++ b/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...)
 }
--- a/logger/structs.go
+++ b/logger/structs.go
@@ -1,10 +1,21 @@
-package logger
+package log
 import "time"
 type LogWriter chan Entry
 type Level int
 const (
 	LTrace Level = iota
 	LDebug
 	LInfo
 	LNotice
 	LWarn
 	LError
 	LPanic
 	LFatal
 )
 type Client struct {
 	LogLevel    Level `json:"level"`
 	writer      LogWriter
@@ -18,3 +29,7 @@ type Entry struct {
 	Level     string    `json:"level"`
 	level     Level
 }
 type Logger struct {
 	FileInfoDepth int
 }
--- a/logger/logger.go
+++ b/logger/logger.go
@@ -1,250 +0,0 @@
 package logger
 import (
 	"errors"
 	"fmt"
 	"os"
 	"runtime"
 	"strings"
 	"sync"
 	"time"
 )
 const (
 	LTrace Level = iota
 	LDebug
 	LInfo
 	LWarn
 	LError
 	LPanic
 	LFatal
 )
 var (
 	clients        []*Client
 	sliceTex       sync.Mutex
 	stderrClient   *Client
 	cleanup        sync.Once
 	stderrFinished chan bool
 )
 func init() {
 	stderrClient = CreateClient()
 	stderrClient.SetLogLevel(LTrace)
 	stderrFinished = make(chan bool, 1)
 	go stderrClient.logStdErr()
 }
 func (c *Client) logStdErr() {
 	for {
 		select {
 		case e, more := <-c.writer:
 			if e.level >= c.LogLevel {
 				fmt.Fprintf(os.Stderr, "%s\t%s\t%s\t%s\n", e.Timestamp.String(), e.Level, e.Output, e.File)
 			}
 			if !more {
 				stderrFinished <- true
 				return
 			}
 		}
 	}
 }
 func CreateClient() *Client {
 	var client Client
 	client.initialized = true
 	client.writer = make(LogWriter, 1000)
 	sliceTex.Lock()
 	clients = append(clients, &client)
 	sliceTex.Unlock()
 	return &client
 }
 func Flush() {
 	cleanup.Do(func() {
 		close(stderrClient.writer)
 		<-stderrFinished
 		stderrClient.Destroy()
 	})
 }
 func (c *Client) Destroy() error {
 	var otherClients []*Client
 	if !c.initialized {
 		panic(errors.New("Cannot delete uninitialized client, did you use CreateClient?"))
 	}
 	sliceTex.Lock()
 	c.writer = nil
 	c.initialized = false
 	for _, x := range clients {
 		if x.initialized {
 			otherClients = append(otherClients, x)
 		}
 	}
 	clients = otherClients
 	sliceTex.Unlock()
 	return nil
 }
 func (c *Client) GetLogLevel() Level {
 	if !c.initialized {
 		panic(errors.New("Cannot get level for uninitialized client, use CreateClient instead"))
 	}
 	return c.LogLevel
 }
 func createLog(e Entry) {
 	sliceTex.Lock()
 	for _, c := range clients {
 		func(c *Client, e Entry) {
 			select {
 			case c.writer <- e:
 				// try to clear out one of the older entries
 			default:
 				select {
 				case <-c.writer:
 					c.writer <- e
 				default:
 				}
 			}
 		}(c, e)
 	}
 	sliceTex.Unlock()
 }
 // SetLogLevel set log level of logger
 func (c *Client) SetLogLevel(level Level) {
 	if !c.initialized {
 		panic(errors.New("Cannot set level for uninitialized client, use CreateClient instead"))
 	}
 	c.LogLevel = level
 }
 func (c *Client) Get() Entry {
 	if !c.initialized {
 		panic(errors.New("Cannot get logs for uninitialized client, did you use CreateClient?"))
 	}
 	return <-c.writer
 }
 // Trace prints out logs on trace level
 func Trace(args ...interface{}) {
 	output := fmt.Sprint(args...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "TRACE",
 		level:     LTrace,
 	}
 	createLog(e)
 	//	entry := logger.WithFields(logrus.Fields{})
 	//	entry.Data["file"] = fileInfo(2)
 	//	entry.Debug(args...)
 }
 // Debug prints out logs on debug level
 func Debug(args ...interface{}) {
 	output := fmt.Sprint(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...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "INFO",
 		level:     LInfo,
 	}
 	createLog(e)
 }
 // Warn prints out logs on warn level
 func Warn(args ...interface{}) {
 	output := fmt.Sprint(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...)
 	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...)
 	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...)
 	e := Entry{
 		Timestamp: time.Now(),
 		Output:    output,
 		File:      fileInfo(2),
 		Level:     "FATAL",
 		level:     LFatal,
 	}
 	createLog(e)
 	Flush()
 	os.Exit(1)
 }
 // fileInfo for getting which line in which file
 func fileInfo(skip int) string {
 	_, file, line, ok := runtime.Caller(skip)
 	if !ok {
 		file = "<???>"
 		line = 1
 	} else {
 		slash := strings.LastIndex(file, "/")
 		if slash >= 0 {
 			file = file[slash+1:]
 		}
 	}
 	return fmt.Sprintf("%s:%d", file, line)
 }
--- a/main.go
+++ b/main.go
@@ -2,21 +2,16 @@ package main
 import (
 	"flag"
 	"html/template"
 	"log"
 	"net/http"
 	"time"
-	"github.com/taigrr/log-socket/logger"
+	"github.com/taigrr/log-socket/browser"
 	logger "github.com/taigrr/log-socket/log"
 	"github.com/taigrr/log-socket/ws"
 )
 var addr = flag.String("addr", "0.0.0.0:8080", "http service address")
 func home(w http.ResponseWriter, r *http.Request) {
 	homeTemplate.Execute(w, "ws://"+r.Host+"/logs")
 }
 func generateLogs() {
 	for {
 		logger.Info("This is an info log!")
@@ -24,204 +19,15 @@ func generateLogs() {
 		logger.Debug("This is a debug log!")
 		logger.Warn("This is a warn log!")
 		logger.Error("This is an error log!")
-		time.Sleep(10 * time.Second)
+		time.Sleep(2 * time.Second)
 	}
 }
 func main() {
 	defer logger.Flush()
 	flag.Parse()
-	http.HandleFunc("/logs", ws.LogSocketHandler)
+	http.HandleFunc("/ws", ws.LogSocketHandler)
-	http.HandleFunc("/", home)
+	http.HandleFunc("/", browser.LogSocketViewHandler)
 	go generateLogs()
-	log.Fatal(http.ListenAndServe(*addr, nil))
+	logger.Fatal(http.ListenAndServe(*addr, nil))
 }
 var homeTemplate = template.Must(template.New("").Parse(`
 <!DOCTYPE html>
 <html>
 <head>
 <meta charset="utf-8">
 </head>
 <body>
 <center>
 <input type="text" id="search" onkeyup="filterTable()" placeholder="Filter...">
 <table id="logHeaders" style="text-align:left; width:80%;" >
 <tbody>
 <tr class="header">
 <th style="width:20%;">TimeStamp</th>
 <th style="width:5%;">Level</th>
 <th style="width:65%;">Output</th>
 <th style="width:10%;">Source</th>
 </tr>
 </tbody>
 </table>
 <div id="tableWrapper">
 <table id="logs" style="text-align:left; width:100%;" >
 <tbody id="tbodylogs">
 <tr class="header">
 <th style="width:20%;"></th>
 <th style="width:5%;"></th>
 <th style="width:65%;"></th>
 <th style="width:10%;"></th>
 </tr>
 </tbody>
 </table>
 </div>
 <br>
 <input class="button" type="button" id="download" value="Download Logs" style="background-color:#3f51b5;"/>
 <input class="button" type="button" id="delete" value="Delete Logs" style="background-color:#f44336"/>
 </center>
 </body>
 <footer>
 <style>
 #tableWrapper{
 	overflow-y: scroll;
 	display: flow-root;
 	width: 80%;
 	height: 80vh;
 }
 td,tr{
 	height: min-content;
 }
 .button{
 	display: inline-block;
 	width: 5vw;
 	height: 5vh;
 }
 </style>
 <script>  
 var logTable = document.getElementById("logs");
 var logTableB = document.getElementById("tbodylogs");
 var ws = null;
 var application = "demo-commit"
 var logs = [];
 function sleep(ms) {
 	return new Promise(resolve => setTimeout(resolve, ms));
 }
 function download(filename, text) {
 	var element = document.createElement('a');
 	element.setAttribute('href', 'data:text/plain;charset=utf-8,' + encodeURIComponent(text));
 	element.setAttribute('download', filename);
 	element.style.display = 'none';
 	document.body.appendChild(element);
 	element.click();
 	document.body.removeChild(element);
 }
 function openSocket() {
 	if (ws) {
 		return false;
 	}
 	ws = new WebSocket("{{.}}");
 	ws.onclose = async function(evt) {
 		ws = null;
 		while(ws == null){
 			openSocket()
 			await sleep(5000);
 		}
 	}
 	ws.onmessage = function(evt) {
 		var entry = JSON.parse(evt.data)
 		logs.push(entry)
 		var row = document.createElement('tr');
 		var ts = document.createElement('td');
 		var tst = document.createTextNode(entry.timestamp);
 		ts.appendChild(tst);
 		row.appendChild(ts);
 		var ts = document.createElement('td');
 		var tst = document.createTextNode(entry.level);
 		ts.appendChild(tst);
 		row.appendChild(ts);
 		var ts = document.createElement('td');
 		var tst = document.createTextNode(entry.output);
 		ts.appendChild(tst);
 		row.appendChild(ts);
 		var ts = document.createElement('td');
 		var tst = document.createTextNode(entry.file);
 		ts.appendChild(tst);
 		row.appendChild(ts);
 		var bg="";
 		switch(entry.level){
 		case "INFO":
 			bg="white";
 			break;
 		case "ERROR":
 			bg="#f44336";
 			break;
 		case "WARN":
 			bg="#fb8c00"
 			break;
 		case "TRACE":
 			bg="#E1F5FE"
 			break;
 		case "DEBUG":
 			bg="#B3E5FC"
 			break;
 		default:
 			bg="white"
 			break;
 		}
 		row.style.backgroundColor=bg
 		logTableB.append(row)
 		filterTable()
 	}
 	ws.onerror = function(evt) {
 		if (evt != null && evt.data != null){
 			// handle error here
 		}
 	}
 }
 function clearTable(){
 	if(!window.confirm("Are you sure you want to delete all logs?")){
 		return
 	}
 	logs = []
 	while (logTableB.childNodes.length > 1) {
 		logTableB.removeChild(logTableB.childNodes[1]);
 	}
 }
 function filterTable() {
 	var cols, input, filter, table, tr, td, i, txtValue, w;
 	input = document.getElementById("search");
 	filter = input.value;
 	table = logTableB;
 	tr = table.getElementsByTagName("tr");
 	for (i = 1; i < tr.length; i++) {
 		cols = tr[i].getElementsByTagName("td");
 		var visible = false;
 		for (w = 0; w < cols.length; w++){
 			if (!visible && cols[w]) {
 				td = cols[w]
 				txtValue = td.textContent || td.innerText;
 				if (txtValue.indexOf(filter) > -1) {
 					visible = true
 				} 
 			}
 		}
 		if(visible){
 			tr[i].style.display = "";
 		} else {
 			tr[i].style.display = "none";
 		}
 	}
 }
 document.getElementById("delete").addEventListener("click", function(){
 	clearTable()
 }, false);
 document.getElementById("download").addEventListener("click", function(){
 	download(application+'.json',JSON.stringify(logs));
 }, false);
 openSocket();
 </script>
 </footer>
 </html>
 `))
--- a/ws/server.go
+++ b/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")
Author	SHA1	Message	Date
Tai Groot	a1e960366e	Merge pull request #11 from ethanholz/log-parity feat: Updated to include print and added ln variants for all logs	2022-10-13 08:05:39 -07:00
Ethan Holz	430181e3a2	feat: Updated to include print and added ln variants for all logs	2022-10-13 09:59:04 -05:00
Tai Groot	147a8cb30b	Merge pull request #10 from ethanholz/README Added a README	2022-10-10 13:38:59 -07:00
Ethan Holz	8e044e3993	docs: Updated README to include running example.	2022-10-10 12:16:52 -05:00
Ethan Holz	e97d37012e	docs: Added inital README	2022-10-10 12:09:29 -05:00
Tai Groot	ebef59a9a8	actually set value for depth	2021-08-23 21:58:05 -07:00
Tai Groot	b3ceb12277	fixes fileinfo reflection issue	2021-08-23 21:45:08 -07:00
Tai Groot	45cad34fdc	fixes fileinfo reflection issue	2021-08-23 21:44:56 -07:00
Tai Groot	f0c16a0c56	fixes fileinfo reflection issue	2021-08-23 21:36:49 -07:00
Tai Groot	c18854598d	Added a logger type	2021-08-23 21:25:01 -07:00
Tai Groot	63ed3a2ad7	logger => log	2021-08-23 21:12:21 -07:00
Tai Groot	f51ec53a89	Adds Notice logging level to support NATS	2021-08-23 20:58:15 -07:00
Tai Groot	d21c91379e	update go compiler target version	2021-08-17 10:07:07 -07:00
Tai Groot	af2116af48	add sponsorship	2021-07-05 21:03:17 -07:00
Tai Groot	b65a10e7a8	detect tls presence based on incoming request for websocket	2021-07-05 16:10:50 -07:00
Tai Groot	a07d3a11df	minor cleanup, adds support for formatted prints	2021-07-03 08:45:19 -07:00
Tai Groot	5f18def7fa	Adds license	2021-04-09 11:09:18 -07:00
Tai Groot	2c7cf0494e	Adds autoscroll feature to browser	2021-04-09 10:39:23 -07:00
Tai Groot	b744f083dc	general refactoring	2021-04-09 10:05:59 -07:00
Tai Groot	1ea76f4ab1	breaks browser out into package	2021-04-09 09:47:49 -07:00
Tai Groot	2e01f23b30	Allow setting of stderr level	2021-04-09 09:40:25 -07:00