Bunch of enhancements...

.github/workflows/go.yml

@@ -1,31 +1,33 @@
-# This workflow will build a golang project
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go
-
 name: Build
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ master ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ master ]
+  workflow_dispatch:
 
 jobs:
-
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: actions/setup-go@v5
+      with:
+        go-version: stable
+    - uses: golangci/golangci-lint-action@v6
   build:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        go: [ '^1.21', 'oldstable', 'stable' ]
     steps:
-    - uses: actions/checkout@v3
-
-    - name: Set up Go
-      uses: actions/setup-go@v4
+    - uses: actions/setup-go@v5
       with:
-        go-version: '1.21'
-
+        go-version: ${{ matrix.go }}
+    - uses: actions/checkout@v4
     - name: Build
-      run: go build -v ./...
-
+      run: |
+        go build "./..."
     - name: Test
-      run: go test -race -coverprofile=coverage.txt -covermode=atomic -v ./...
-
-    - name: Upload coverage to Codecov
-      uses: codecov/codecov-action@v3
+      run: go test -v -json ./...

README.md

@@ -1,12 +1,12 @@
 # console-slog
 
-[![Go Reference](https://pkg.go.dev/badge/github.com/phsym/console-slog.svg)](https://pkg.go.dev/github.com/phsym/console-slog) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/phsym/console-slog/master/LICENSE) [![Build](https://github.com/phsym/console-slog/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/phsym/slog-console/actions/workflows/go.yml) [![codecov](https://codecov.io/gh/phsym/console-slog/graph/badge.svg?token=ZIJT9L79QP)](https://codecov.io/gh/phsym/console-slog) [![Go Report Card](https://goreportcard.com/badge/github.com/phsym/console-slog)](https://goreportcard.com/report/github.com/phsym/console-slog)
+[![Go Reference](https://pkg.go.dev/badge/github.com/ansel1/console-slog.svg)](https://pkg.go.dev/github.com/ansel1/console-slog) [![license](http://img.shields.io/badge/license-MIT-red.svg?style=flat)](https://raw.githubusercontent.com/ansel1/console-slog/master/LICENSE) [![Build](https://github.com/ansel1/console-slog/actions/workflows/go.yml/badge.svg?branch=main)](https://github.com/ansel1/slog-console/actions/workflows/go.yml) [![codecov](https://codecov.io/gh/ansel1/console-slog/graph/badge.svg?token=ZIJT9L79QP)](https://codecov.io/gh/ansel1/console-slog) [![Go Report Card](https://goreportcard.com/badge/github.com/ansel1/console-slog)](https://goreportcard.com/report/github.com/ansel1/console-slog)
 
 A handler for slog that prints colorized logs, similar to zerolog's console writer output without sacrificing performances.
 
 ## Installation
 ```bash
-go get github.com/phsym/console-slog@latest
+go get github.com/ansel1/console-slog@latest
 ```
 
 ## Example
@@ -18,7 +18,7 @@ import (
 	"log/slog"
 	"os"
 
-	"github.com/phsym/console-slog"
+	"github.com/ansel1/console-slog"
 )
 
 func main() {
@@ -50,26 +50,9 @@ console.NewHandler(os.Stderr, &console.HandlerOptions{Level: slog.LevelDebug, Ad
 ## Performances
 See [benchmark file](./bench_test.go) for details.
 
-The handler itself performs quite well compared to std-lib's handlers. It does no allocation:
-```
-goos: linux
-goarch: amd64
-pkg: github.com/phsym/console-slog
-cpu: Intel(R) Core(TM) i5-6300U CPU @ 2.40GHz
-BenchmarkHandlers/dummy-4               128931026            8.732 ns/op               0 B/op          0 allocs/op
-BenchmarkHandlers/console-4               849837              1294 ns/op               0 B/op          0 allocs/op
-BenchmarkHandlers/std-text-4              542583              2097 ns/op               4 B/op          2 allocs/op
-BenchmarkHandlers/std-json-4              583784              1911 ns/op             120 B/op          3 allocs/op
-```
+The handler itself performs quite well compared to std-lib's handlers. It does no allocation.  It is generally faster
+then slog.TextHandler, and a little slower than slog.JSONHandler.
 
-However, the go 1.21.0 `slog.Logger` adds some overhead:
-```
-goos: linux
-goarch: amd64
-pkg: github.com/phsym/console-slog
-cpu: Intel(R) Core(TM) i5-6300U CPU @ 2.40GHz
-BenchmarkLoggers/dummy-4                 1239873             893.2 ns/op             128 B/op          1 allocs/op
-BenchmarkLoggers/console-4                483354              2338 ns/op             128 B/op          1 allocs/op
-BenchmarkLoggers/std-text-4               368828              3141 ns/op             132 B/op          3 allocs/op
-BenchmarkLoggers/std-json-4               393322              2909 ns/op             248 B/op          4 allocs/op
-```
+## Credit
+
+This is a forked and heavily modified variant of github.com/phsym/console-slog.

bench_test.go

@@ -22,7 +22,11 @@ var handlers = []struct {
 }{
 	{"dummy", &DummyHandler{}},
 	{"console", NewHandler(io.Discard, &HandlerOptions{Level: slog.LevelDebug, AddSource: false})},
+	{"console-headers", NewHandler(io.Discard, &HandlerOptions{HeaderFormat: "%t %{%[foo]h > %}%l %m %a", Level: slog.LevelDebug, AddSource: false})},
+	{"console-replaceattr", NewHandler(io.Discard, &HandlerOptions{Level: slog.LevelDebug, AddSource: false, ReplaceAttr: func(_ []string, a slog.Attr) slog.Attr { return a }})},
+	{"console-headers-replaceattr", NewHandler(io.Discard, &HandlerOptions{HeaderFormat: "%t %{%[foo]h > %} %l %m %a", Level: slog.LevelDebug, AddSource: false, ReplaceAttr: func(_ []string, a slog.Attr) slog.Attr { return a }})},
 	{"std-text", slog.NewTextHandler(io.Discard, &slog.HandlerOptions{Level: slog.LevelDebug, AddSource: false})},
+	{"std-text-replaceattr", slog.NewTextHandler(io.Discard, &slog.HandlerOptions{Level: slog.LevelDebug, AddSource: false, ReplaceAttr: func(_ []string, a slog.Attr) slog.Attr { return a }})},
 	{"std-json", slog.NewJSONHandler(io.Discard, &slog.HandlerOptions{Level: slog.LevelDebug, AddSource: false})},
 }
 
@@ -36,6 +40,7 @@ var attrs = []slog.Attr{
 	slog.Any("err", errors.New("yo")),
 	slog.Group("empty"),
 	slog.Group("group", slog.String("bar", "baz")),
+	slog.String("multi", "foo\nbar"),
 }
 
 var attrsAny = func() (a []any) {

buffer.go

@@ -2,31 +2,20 @@ package console
 
 import (
 	"io"
-	"slices"
 	"strconv"
 	"time"
 )
 
 type buffer []byte
 
-func (b *buffer) Grow(n int) {
-	*b = slices.Grow(*b, n)
-}
-
-func (b *buffer) Bytes() []byte {
-	return *b
-}
-
 func (b *buffer) String() string {
 	return string(*b)
 }
 
-func (b *buffer) Len() int {
-	return len(*b)
-}
-
-func (b *buffer) Cap() int {
-	return cap(*b)
+func (b *buffer) Pad(n int, c byte) {
+	for ; n > 0; n-- {
+		b.AppendByte(byte(c))
+	}
 }
 
 func (b *buffer) WriteTo(dst io.Writer) (int64, error) {
@@ -45,22 +34,19 @@ func (b *buffer) WriteTo(dst io.Writer) (int64, error) {
 	return int64(n), nil
 }
 
-func (b *buffer) Reset() {
-	*b = (*b)[:0]
-}
-
-func (b *buffer) Clone() buffer {
-	return append(buffer(nil), *b...)
-}
-
-func (b *buffer) Clip() {
-	*b = slices.Clip(*b)
+func (b *buffer) Write(bt []byte) (int, error) {
+	*b = append(*b, bt...)
+	return len(bt), nil
 }
 
-func (b *buffer) copy(src *buffer) {
-	if src.Len() > 0 {
-		b.Append(src.Bytes())
+func (b *buffer) Reset() {
+	// To reduce peak allocation, return only smaller buffers to the pool.
+	const maxBufferSize = 16 << 10
+	if cap(*b) > maxBufferSize {
+		*b = (*b)[:0:maxBufferSize]
+		return
 	}
+	*b = (*b)[:0]
 }
 
 func (b *buffer) Append(data []byte) {
@@ -71,10 +57,6 @@ func (b *buffer) AppendString(s string) {
 	*b = append(*b, s...)
 }
 
-// func (b *buffer) AppendQuotedString(s string) {
-// 	b.buff = strconv.AppendQuote(b.buff, s)
-// }
-
 func (b *buffer) AppendByte(byt byte) {
 	*b = append(*b, byt)
 }

buffer_test.go

@@ -9,16 +9,16 @@ import (
 )
 
 func TestBuffer_Append(t *testing.T) {
-	b := new(buffer)
-	AssertZero(t, b.Len())
+	var b buffer
+	AssertZero(t, len(b))
 	b.AppendString("foobar")
-	AssertEqual(t, 6, b.Len())
+	AssertEqual(t, 6, len(b))
 	b.AppendString("baz")
-	AssertEqual(t, 9, b.Len())
+	AssertEqual(t, 9, len(b))
 	AssertEqual(t, "foobarbaz", b.String())
 
 	b.AppendByte('.')
-	AssertEqual(t, 10, b.Len())
+	AssertEqual(t, 10, len(b))
 	AssertEqual(t, "foobarbaz.", b.String())
 
 	b.AppendBool(true)
@@ -36,7 +36,7 @@ func TestBuffer_Append(t *testing.T) {
 
 func TestBuffer_WriteTo(t *testing.T) {
 	dest := bytes.Buffer{}
-	b := new(buffer)
+	var b buffer
 	n, err := b.WriteTo(&dest)
 	AssertNoError(t, err)
 	AssertZero(t, n)
@@ -45,61 +45,23 @@ func TestBuffer_WriteTo(t *testing.T) {
 	AssertEqual(t, len("foobar"), int(n))
 	AssertNoError(t, err)
 	AssertEqual(t, "foobar", dest.String())
-	AssertZero(t, b.Len())
-}
-
-func TestBuffer_Clone(t *testing.T) {
-	b := new(buffer)
-	b.AppendString("foobar")
-	b2 := b.Clone()
-	AssertEqual(t, b.String(), b2.String())
-	AssertNotEqual(t, &b.Bytes()[0], &b2.Bytes()[0])
-}
-
-func TestBuffer_Copy(t *testing.T) {
-	b := new(buffer)
-	b.AppendString("foobar")
-	b2 := new(buffer)
-	b2.copy(b)
-	AssertEqual(t, b.String(), b2.String())
-	AssertNotEqual(t, &b.Bytes()[0], &b2.Bytes()[0])
+	AssertZero(t, len(b))
 }
 
 func TestBuffer_Reset(t *testing.T) {
-	b := new(buffer)
+	var b buffer
 	b.AppendString("foobar")
 	AssertEqual(t, "foobar", b.String())
-	AssertEqual(t, len("foobar"), b.Len())
-	bufCap := b.Cap()
+	AssertEqual(t, len("foobar"), len(b))
+	bufCap := cap(b)
 	b.Reset()
-	AssertZero(t, b.Len())
-	AssertEqual(t, bufCap, b.Cap())
-}
-
-func TestBuffer_Grow(t *testing.T) {
-	b := new(buffer)
-	AssertZero(t, b.Cap())
-	b.Grow(12)
-	AssertGreaterOrEqual(t, 12, b.Cap())
-	b.Grow(6)
-	AssertGreaterOrEqual(t, 12, b.Cap())
-	b.Grow(24)
-	AssertGreaterOrEqual(t, 24, b.Cap())
-}
-
-func TestBuffer_Clip(t *testing.T) {
-	b := new(buffer)
-	b.AppendString("foobar")
-	b.Grow(12)
-	AssertGreaterOrEqual(t, 12, b.Cap())
-	b.Clip()
-	AssertEqual(t, "foobar", b.String())
-	AssertEqual(t, len("foobar"), b.Cap())
+	AssertZero(t, len(b))
+	AssertEqual(t, bufCap, cap(b))
 }
 
 func TestBuffer_WriteTo_Err(t *testing.T) {
 	w := writerFunc(func(b []byte) (int, error) { return 0, errors.New("nope") })
-	b := new(buffer)
+	var b buffer
 	b.AppendString("foobar")
 	_, err := b.WriteTo(w)
 	AssertError(t, err)

duration_test.go

@@ -2,6 +2,7 @@ package console
 
 import (
 	"bytes"
+	"slices"
 	"testing"
 	"time"
 )
@@ -43,8 +44,7 @@ func BenchmarkDuration(b *testing.B) {
 	})
 
 	b.Run("append", func(b *testing.B) {
-		w := new(buffer)
-		w.Grow(2048)
+		w := slices.Grow(buffer{}, 2048)
 		b.ResetTimer()
 		for i := 0; i < b.N; i++ {
 			w.AppendDuration(d)