initial commit

Author: trevatk

.github/workflows/go.yml

@@ -0,0 +1,18 @@
+name: Go Test
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+
+jobs:
+  build:
+    name: Go Unit Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-go@v6
+        with: 
+          go-version: '1.25'
+          
+      - run: go test -v ./...

Makefile

@@ -0,0 +1,6 @@
+
+test:
+	@go test -v ./...
+
+bench:
+	@go test -bench=BenchmarkLogger_JSON -benchtime=10s -benchmem

attr.go

@@ -0,0 +1,58 @@
+package teapot
+
+// Attr
+type Attr struct {
+	key    string
+	kfield kField
+
+	intValue    int
+	int16Value  int16
+	int32Value  int32
+	int64Value  int64
+	stringValue string
+	boolValue   bool
+
+	anyValue any
+
+	errValue error
+}
+
+// Int
+func Int(key string, value int) Attr {
+	return Attr{key: key, kfield: kint, intValue: value}
+}
+
+// Int16
+func Int16(key string, value int16) Attr {
+	return Attr{key: key, kfield: kint16, int16Value: value}
+}
+
+// Int32
+func Int32(key string, value int32) Attr {
+	return Attr{key: key, kfield: kint32, int32Value: value}
+}
+
+// Int64
+func Int64(key string, value int64) Attr {
+	return Attr{key: key, kfield: kint64, int64Value: value}
+}
+
+// Bool
+func Bool(key string, value bool) Attr {
+	return Attr{key: key, kfield: kbool, boolValue: value}
+}
+
+// String
+func String(key, value string) Attr {
+	return Attr{key: key, kfield: kstring, stringValue: value}
+}
+
+// Any
+func Any(key string, value any) Attr {
+	return Attr{key: key, kfield: kany, anyValue: value}
+}
+
+// Error
+func Error(err error) Attr {
+	return Attr{key: "error", kfield: kerr, errValue: err}
+}

const.go

@@ -0,0 +1,33 @@
+package teapot
+
+type Level int
+
+const (
+	DEBUG Level = iota
+	INFO
+	WARN
+	ERROR
+	FATAL
+)
+
+var levelName = []string{"DEBUG", "INFO", "WARN", "ERROR", "FATAL"}
+
+type Format int
+
+const (
+	TEXT Format = iota
+	JSON
+)
+
+type kField int
+
+const (
+	kint kField = iota
+	kint16
+	kint32
+	kint64
+	kbool
+	kany
+	kstring
+	kerr
+)

go.mod

@@ -0,0 +1,3 @@
+module github.com/structx/teapot
+
+go 1.25.5

log.go

@@ -0,0 +1,147 @@
+package teapot
+
+import (
+	"io"
+	"os"
+	"runtime"
+	"strconv"
+	"sync"
+	"time"
+)
+
+// Option
+type Option func(*Logger)
+
+// WithLevel
+func WithLevel(level Level) Option { return func(l *Logger) { l.lvl = level } }
+
+// WithWriter
+func WithWriter(w io.Writer) Option { return func(l *Logger) { l.w = w } }
+
+// Logger
+type Logger struct {
+	mu sync.Mutex
+	p  *sync.Pool
+
+	w io.Writer
+
+	lvl Level
+	f   Format
+}
+
+// New
+func New(opts ...Option) *Logger {
+	l := &Logger{
+		w:   os.Stdout,
+		lvl: DEBUG,
+		f:   JSON,
+		mu:  sync.Mutex{},
+		p: &sync.Pool{
+			New: func() any {
+				buf := make([]byte, 0, 1024)
+				return &buf
+			},
+		},
+	}
+	for _, o := range opts {
+		o(l)
+	}
+	return l
+}
+
+// Debug
+func (l *Logger) Debug(format string, attrs ...Attr) {
+	l.printf(format, DEBUG, attrs...)
+}
+
+// Debugf
+func (l *Logger) Debugf(format string, attrs ...Attr) {
+	l.printf(format, INFO, attrs...)
+}
+
+// Info
+func (l *Logger) Info(format string) {
+	l.printf(format, INFO)
+}
+
+// Infof
+func (l *Logger) Infof(format string, attrs ...Attr) {
+	l.printf(format, INFO, attrs...)
+}
+
+// Error
+func (l *Logger) Error(format string, attrs ...Attr) {
+	l.printf(format, ERROR, attrs...)
+}
+
+// Fatal
+func (l *Logger) Fatal(format string, attrs ...Attr) {
+	l.printf(format, FATAL, attrs...)
+	os.Exit(1)
+}
+
+func (l *Logger) printf(format string, level Level, attrs ...Attr) {
+	if level < l.lvl {
+		return
+	}
+
+	ptr := l.p.Get().(*[]byte)
+	buf := (*ptr)[:0]
+
+	switch l.f {
+	// TODO
+	// implement text logger
+	// case TEXT:
+	case JSON:
+		buf = append(buf, `{"time":"`...)
+		buf = time.Now().UTC().AppendFormat(buf, time.RFC3339Nano)
+		buf = append(buf, `", "level":"`...)
+		buf = append(buf, levelName[l.lvl]...)
+		buf = append(buf, `", "message":"`...)
+		buf = append(buf, format...)
+		buf = append(buf, `"`...)
+		for _, attr := range attrs {
+			buf = append(buf, `,"`...)
+			buf = append(buf, attr.key...)
+			buf = append(buf, `":`...)
+
+			switch attr.kfield {
+			case kint:
+				buf = strconv.AppendInt(buf, int64(attr.intValue), 10)
+			case kint16:
+				buf = strconv.AppendInt(buf, int64(attr.int16Value), 10)
+			case kint32:
+				buf = strconv.AppendInt(buf, int64(attr.int32Value), 10)
+			case kint64:
+				buf = strconv.AppendInt(buf, attr.int64Value, 10)
+			case kbool:
+				buf = strconv.AppendBool(buf, attr.boolValue)
+			case kstring:
+				buf = strconv.AppendQuote(buf, attr.stringValue)
+			case kerr:
+				buf = strconv.AppendQuote(buf, attr.errValue.Error())
+			}
+		}
+
+		if level >= ERROR {
+			buf = append(buf, `, "stacktrace":`...)
+
+			var sb = make([]byte, 2048)
+			n := runtime.Stack(sb, false)
+			buf = strconv.AppendQuote(buf, string(sb[:n]))
+		}
+
+		buf = append(buf, "}"...)
+	default:
+		return
+	}
+
+	buf = append(buf, '\n')
+
+	l.mu.Lock()
+	l.w.Write(buf)
+	l.mu.Unlock()
+
+	*ptr = buf
+	l.p.Put(ptr)
+}

log_benchmark_test.go

@@ -0,0 +1,25 @@
+package teapot
+
+import (
+	"io"
+	"testing"
+)
+
+func BenchmarkLogger_JSON(b *testing.B) {
+	l := New(
+		WithWriter(io.Discard), // does not measure os write performance
+	)
+
+	attrs := []Attr{
+		String("user", "alice"),
+		Int("status", 200),
+		Bool("success", true),
+	}
+
+	b.ResetTimer()
+	b.RunParallel(func(p *testing.PB) {
+		for p.Next() {
+			l.Debug("received request", attrs...)
+		}
+	})
+}

log_test.go

@@ -0,0 +1,65 @@
+package teapot
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func TestLogger_Levels(t *testing.T) {
+	var buf bytes.Buffer
+
+	l := New(
+		WithLevel(INFO),
+		WithWriter(&buf),
+	)
+
+	l.printf("hello", DEBUG)
+	if buf.Len() > 0 {
+		t.Fatal("expected empty buffer")
+	}
+
+	l.printf("hello", INFO)
+	if buf.Len() == 0 {
+		t.Fatal("expected non empty buffer")
+	}
+}
+
+func TestLogger_JSON(t *testing.T) {
+	var buf bytes.Buffer
+
+	l := New(
+		WithLevel(INFO),
+		WithWriter(&buf),
+	)
+
+	l.Infof("hello",
+		String("user", "alice"),
+	)
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(buf.Bytes(), &result); err != nil {
+		t.Fatalf("json.Unmarshal: %v", err)
+	}
+
+	if result["user"] != "alice" {
+		t.Fatalf("unexpected user value %s expected alice", result["user"])
+	}
+}
+
+func TestLogger_Error(t *testing.T) {
+	var buf bytes.Buffer
+
+	l := New(
+		WithLevel(ERROR),
+		WithWriter(&buf),
+	)
+
+	e := errors.New("something happened")
+
+	l.Error("this is bad", Error(e))
+
+	fmt.Println(buf.String())
+}