more or less functional draft

This commit is contained in:
Jeff Carr 2023-12-30 20:48:24 -06:00
parent 424a1b42e2
commit d7d3fbc3a3
8 changed files with 196 additions and 15 deletions

32
doc.go Normal file
View File

@ -0,0 +1,32 @@
package log
//
// version v1.5
//
// I like things to be easy.
//
// this means all the log settings are in one place. it should allow
// things to be over-ridden externally to the library
// but still allow command line --args to pass debugging settings
//
// I also have a generic sleep() and exit() in here because it's simple
//
// Usage:
//
// log.Info("something", foo, bar)
// log.Bool(DEBUG, "something else", someOtherVariable) # if DEBUG == false, return doing nothing
//
/*
I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
implementation is probably faster than all of those because you just set one bool to FALSE
and it all stops.
Sometimes I need to capture to stdout, sometimes stdout can't
work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread
over 8 million references in every .go file. I'm tapping out and putting
it in one place. here it is. Also, this makes having debug levels really fucking easy.
You can define whatever level of logging you want from anywhere (command line) etc.
log() # doesn't do anything
log(stuff) # sends it to whatever log you define in a single place. here is the place
*/

View File

@ -4,6 +4,7 @@ import (
origlog "log"
)
func Error(a ...any) {
func Error(err error, a ...any) {
origlog.Println("Error:", err)
origlog.Println(a...)
}

15
info.go
View File

@ -1,23 +1,10 @@
package log
import (
"os"
golanglog "log"
)
func Info(a ...any) {
if ! INFO { return }
golanglog.Println(a...)
}
// start writing all the logging to a tmp file
func SetTmp() {
f, err := os.OpenFile("/tmp/guilogfile", os.O_RDWR | os.O_CREATE | os.O_APPEND, 0666)
if err != nil {
golanglog.Fatalf("error opening file: %v", err)
}
// hmm. is there a trick here or must this be in main()
// defer f.Close()
golanglog.SetOutput(f)
golanglog.Println("This is a test log entry")
}

44
log.go
View File

@ -1,9 +1,53 @@
package log
import (
"errors"
origlog "log"
)
var SPEW bool = true
var INFO bool = true
var WARN bool = true
var ERROR bool = true
func All(b bool) {
Set("SPEW", b)
Set("INFO", b)
Set("WARN", b)
Set("ERROR", b)
}
func Set(flag string, b bool) {
switch flag {
case "INFO":
INFO = b
case "WARN":
WARN = b
case "SPEW":
SPEW = b
case "ERROR":
ERROR = b
default:
Error(errors.New("unknown flag"), "Flag name sent:", flag)
}
}
func Get(flag string) bool {
switch flag {
case "INFO":
return INFO
case "WARN":
return WARN
case "SPEW":
return SPEW
case "ERROR":
return ERROR
default:
Error(errors.New("unknown flag"), "Flag name sent:", flag)
}
return false
}
func Println(a ...any) {
origlog.Println(a...)
}

19
output.go Normal file
View File

@ -0,0 +1,19 @@
package log
import (
"os"
golanglog "log"
)
// start writing all the logging to a tmp file
func SetTmp() {
f, err := os.OpenFile("/tmp/guilogfile", os.O_RDWR | os.O_CREATE | os.O_APPEND, 0666)
if err != nil {
golanglog.Fatalf("error opening file: %v", err)
}
// hmm. is there a trick here or must this be in main()
// defer f.Close()
golanglog.SetOutput(f)
golanglog.Println("This is a test log entry")
}

77
sleep.go Normal file
View File

@ -0,0 +1,77 @@
package log
//
// version v1.2
//
// I like things to be easy.
//
// this means all the log settings are in one place. it should allow
// things to be over-ridden externally to the library
// but still allow command line --args to pass debugging settings
//
// I also have a generic sleep() and exit() in here because it's simple
//
// Usage:
//
// log("something", foo, bar)
// var DEBUG bool = true
// log(DEBUG, "something else", someOtherVariable) # if DEBUG == false, return doing nothing
//
/*
I've spent, am spending, too much time thinking about 'logging'. 'log', 'logrus', 'zap', whatever.
I'm not twitter. i don't give a fuck about how many nanoseconds it takes to log. Anyway, this
implementation is probably faster than all of those because you just set one bool to FALSE
and it all stops.
Sometimes I need to capture to stdout, sometimes stdout can't
work because it doesn't exist for the user. This whole thing is a PITA. Then it's spread
over 8 million references in every .go file. I'm tapping out and putting
it in one place. here it is. Also, this makes having debug levels really fucking easy.
You can define whatever level of logging you want from anywhere (command line) etc.
log() # doesn't do anything
log(stuff) # sends it to whatever log you define in a single place. here is the place
*/
import (
"os"
"time"
"errors"
"reflect"
origlog "log"
)
/*
sleep() # you know what this does? sleeps for 1 second. yep. dump. easy.
sleep(.1) # you know what this does? yes, it sleeps for 1/10th of a second
*/
func Sleep(a ...any) {
if (a == nil) {
time.Sleep(time.Second)
return
}
origlog.Println("sleep", a[0])
switch a[0].(type) {
case int:
time.Sleep(time.Duration(a[0].(int)) * time.Second)
case float64:
time.Sleep(time.Duration(a[0].(float64) * 1000) * time.Millisecond)
default:
origlog.Println("sleep a[0], type = ", a[0], reflect.TypeOf(a[0]))
}
}
/*
exit() # yep. exits. I guess everything must be fine
exit(3) # I guess 3 it is then
exit("dont like apples") # ok. I'll make a note of that
*/
func Exit(a ...any) {
Error(errors.New("Exit"), a)
//if (a) {
// os.Exit(a)
//}
os.Exit(0)
}

20
spew.go Normal file
View File

@ -0,0 +1,20 @@
package log
import (
origlog "log"
"github.com/davecgh/go-spew/spew"
)
func Spew(a ...any) {
if ! SPEW { return }
origlog.Println("SPEW:", spew.Sdump(a...))
/*
scs := spew.ConfigState{Indent: "\t", MaxDepth: 1}
// Output using the ConfigState instance.
v := map[string]int{"one": 1}
scs.Printf("v: %v\n", v)
scs.Dump(v)
scs.Dump(a)
*/
}

View File

@ -5,5 +5,6 @@ import (
)
func Warn(a ...any) {
if ! WARN { return }
origlog.Println(a...)
}