Build tags for smaller binaries that don't need net/http or encoding/json

.gitignore

@@ -1 +1,6 @@
+.DS_Store
 .golangci.yml
+fullsize
+smallsize
+coverage.out
+coverage?.out

.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch test function with tags",
+            "type": "go",
+            "request": "launch",
+            "mode": "test",
+            "program": "${workspaceFolder}",
+            "buildFlags": "-tags=no_json"
+        }
+
+    ]
+}

Makefile

@@ -2,7 +2,22 @@
 all: test example
 
 test:
-	go test . -race ./...
+	go test -race ./...
+	go test -tags no_json ./...
+	go test -tags no_http ./...
+
+local-coverage: coverage
+	go test -coverprofile=coverage.out ./...
+	go tool cover -html=coverage.out
+
+coverage:
+	go test -coverprofile=coverage1.out ./...
+	go test -tags no_net -coverprofile=coverage2.out ./...
+	go test -tags no_json -coverprofile=coverage3.out ./...
+	go test -tags no_http,no_json -coverprofile=coverage4.out ./...
+	# cat coverage*.out > coverage.out
+	go install github.com/wadey/gocovmerge@b5bfa59ec0adc420475f97f89b58045c721d761c
+	gocovmerge coverage?.out > coverage.out
 
 example:
 	@echo "### Colorized (default) ###"
@@ -17,6 +32,16 @@ line:
 screenshot: line example
 	@echo
 
+size-check:
+	@echo "### Size of the binary:"
+	CGO_ENABLED=0 go build -ldflags="-w -s" -trimpath -o ./fullsize ./levelsDemo
+	ls -lh ./fullsize
+	CGO_ENABLED=0 go build -tags no_net -ldflags="-w -s" -trimpath -o ./smallsize ./levelsDemo
+	ls -lh ./smallsize
+	CGO_ENABLED=0 go build -tags no_http,no_json -ldflags="-w -s" -trimpath -o ./smallsize ./levelsDemo
+	ls -lh ./smallsize
+	gsa ./smallsize # go install github.com/Zxilly/go-size-analyzer/cmd/gsa@master
+
 
 lint: .golangci.yml
 	golangci-lint run

README.md

@@ -100,3 +100,11 @@ LOGGER_GOROUTINE_ID=false
 LOGGER_COMBINE_REQUEST_AND_RESPONSE=true
 LOGGER_LEVEL='Info'
 ```
+
+# Small binaries
+
+If you're never logging http requests/responses, use `-tags no_http` (or `-tags no_net`) to exclude the http/https logging utilities (which pulls in a lot of dependencies because of `net/http` init).
+
+If you never need to JSON log complex structures/types that have a special `json.Marshaler` then you can use `-tags no_net,no_json` for the smallest executables
+
+(see `make size-check`)

codecov.yml

@@ -0,0 +1,6 @@
+coverage:
+  ignore:
+    - "levelsDemo"
+# not used (is nothing at all used?)
+#  files:
+#    - "coverage*.out"

http_logging.go

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:build !no_http && !no_net
+// +build !no_http,!no_net
+
 package log
 
 import (

http_logging_test.go

@@ -1,3 +1,6 @@
+//go:build !no_http && !no_net
+// +build !no_http,!no_net
+
 package log // import "fortio.org/fortio/log"
 
 import (

json_logging.go

@@ -0,0 +1,67 @@
+// Copyright 2017-2024 Fortio Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Moved json logging out so it can be skipped for smallest binaries based on build tags.
+// only difference is with nested struct/array logging or logging of types with json Marchaller interface.
+
+//go:build !no_json
+
+package log // import "fortio.org/log"
+
+import (
+	"encoding/json"
+	"fmt"
+	"strconv"
+)
+
+var fullJSON = true
+
+func toJSON(v any) string {
+	bytes, err := json.Marshal(v)
+	if err != nil {
+		return strconv.Quote(fmt.Sprintf("ERR marshaling %v: %v", v, err))
+	}
+	str := string(bytes)
+	// We now handle errors before calling toJSON: if there is a marshaller we use it
+	// otherwise we use the string from .Error()
+	return str
+}
+
+func (v ValueType[T]) String() string {
+	// if the type is numeric, use Sprint(v.val) otherwise use Sprintf("%q", v.Val) to quote it.
+	switch s := any(v.Val).(type) {
+	case bool, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64,
+		float32, float64:
+		return fmt.Sprint(s)
+	case string:
+		return fmt.Sprintf("%q", s)
+	case error:
+		// Sadly structured errors like nettwork error don't have the reason in
+		// the exposed struct/JSON - ie on gets
+		// {"Op":"read","Net":"tcp","Source":{"IP":"127.0.0.1","Port":60067,"Zone":""},
+		// "Addr":{"IP":"127.0.0.1","Port":3000,"Zone":""},"Err":{}}
+		// instead of
+		// read tcp 127.0.0.1:60067->127.0.0.1:3000: i/o timeout
+		// Noticed in https://github.com/fortio/fortio/issues/913
+		_, hasMarshaller := s.(json.Marshaler)
+		if hasMarshaller {
+			return toJSON(v.Val)
+		} else {
+			return fmt.Sprintf("%q", s.Error())
+		}
+	/* It's all handled by json fallback now even though slightly more expensive at runtime, it's a lot simpler */
+	default:
+		return toJSON(v.Val) // was fmt.Sprintf("%q", fmt.Sprint(v.Val))
+	}
+}

json_logging_test.go

@@ -0,0 +1,20 @@
+//go:build !no_json
+// +build !no_json
+
+package log // import "fortio.org/fortio/log"
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestToJSON_MarshalError(t *testing.T) {
+	badValue := make(chan int)
+
+	expected := fmt.Sprintf("\"ERR marshaling %v: %v\"", badValue, "json: unsupported type: chan int")
+	actual := toJSON(badValue)
+
+	if actual != expected {
+		t.Errorf("Expected %q, got %q", expected, actual)
+	}
+}

logger.go

@@ -25,7 +25,6 @@ package log // import "fortio.org/log"
 
 import (
 	"bytes"
-	"encoding/json"
 	"flag"
 	"fmt"
 	"io"
@@ -349,7 +348,7 @@ func Logf(lvl Level, format string, rest ...interface{}) {
 	logPrintf(lvl, format, rest...)
 }
 
-// Used when doing our own logging writing, in JSON/structured mode.
+// Used when doing our own logging writing, in JSON/structured mode (and some color variants as well, misnomer).
 var (
 	jWriter = jsonWriter{w: os.Stderr, tsBuf: make([]byte, 0, 32)}
 )
@@ -631,45 +630,6 @@ type ValueType[T ValueTypes] struct {
 	Val T
 }
 
-func toJSON(v any) string {
-	bytes, err := json.Marshal(v)
-	if err != nil {
-		return strconv.Quote(fmt.Sprintf("ERR marshaling %v: %v", v, err))
-	}
-	str := string(bytes)
-	// We now handle errors before calling toJSON: if there is a marshaller we use it
-	// otherwise we use the string from .Error()
-	return str
-}
-
-func (v ValueType[T]) String() string {
-	// if the type is numeric, use Sprint(v.val) otherwise use Sprintf("%q", v.Val) to quote it.
-	switch s := any(v.Val).(type) {
-	case bool, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64,
-		float32, float64:
-		return fmt.Sprint(s)
-	case string:
-		return fmt.Sprintf("%q", s)
-	case error:
-		// Sadly structured errors like nettwork error don't have the reason in
-		// the exposed struct/JSON - ie on gets
-		// {"Op":"read","Net":"tcp","Source":{"IP":"127.0.0.1","Port":60067,"Zone":""},
-		// "Addr":{"IP":"127.0.0.1","Port":3000,"Zone":""},"Err":{}}
-		// instead of
-		// read tcp 127.0.0.1:60067->127.0.0.1:3000: i/o timeout
-		// Noticed in https://github.com/fortio/fortio/issues/913
-		_, hasMarshaller := s.(json.Marshaler)
-		if hasMarshaller {
-			return toJSON(v.Val)
-		} else {
-			return fmt.Sprintf("%q", s.Error())
-		}
-	/* It's all handled by json fallback now even though slightly more expensive at runtime, it's a lot simpler */
-	default:
-		return toJSON(v.Val) // was fmt.Sprintf("%q", fmt.Sprint(v.Val))
-	}
-}
-
 // Our original name, now switched to slog style Any.
 func Attr[T ValueTypes](key string, value T) KeyVal {
 	return Any(key, value)

logger_test.go

@@ -767,6 +767,58 @@ func (e customError) MarshalJSON() ([]byte, error) {
 	return json.Marshal(customErrorAlias(e))
 }
 
+func TestPointers(t *testing.T) {
+	var iPtr *int
+	kv := Any("err", iPtr)
+	kvStr := kv.StringValue()
+	expected := `null`
+	if kvStr != expected {
+		t.Errorf("unexpected:\n%s\nvs:\n%s\n", kvStr, expected)
+	}
+	i := 42
+	iPtr = &i
+	kv = Any("int", iPtr)
+	kvStr = kv.StringValue()
+	expected = `42`
+	if kvStr != expected {
+		t.Errorf("unexpected:\n%s\nvs:\n%s\n", kvStr, expected)
+	}
+	var sPtr *string
+	kv = Any("msg", sPtr)
+	kvStr = kv.StringValue()
+	expected = `null`
+	if kvStr != expected {
+		t.Errorf("unexpected:\n%s\nvs:\n%s\n", kvStr, expected)
+	}
+	s := "test\nline2"
+	sPtr = &s
+	kv = Any("msg", sPtr)
+	kvStr = kv.StringValue()
+	expected = `"test\nline2"`
+	if kvStr != expected {
+		t.Errorf("unexpected:\n%s\nvs:\n%s\n", kvStr, expected)
+	}
+}
+
+func TestStruct(t *testing.T) {
+	type testStruct struct {
+		Msg1 string
+		Msg2 *string
+	}
+	ptrStr := "test2"
+	ts := testStruct{Msg1: "test\nline2", Msg2: &ptrStr}
+	kv := Any("ts", ts)
+	kvStr := kv.StringValue()
+	expected := `{"Msg1":"test\nline2","Msg2":"test2"}`
+	if !fullJSON {
+		expected = `"{Msg1:test\nline2 Msg2:`
+		expected += fmt.Sprintf("%p}\"", &ptrStr)
+	}
+	if kvStr != expected {
+		t.Errorf("unexpected:\n%s\nvs:\n%s\n", kvStr, expected)
+	}
+}
+
 func TestSerializationOfError(t *testing.T) {
 	var err error
 	kv := Any("err", err)
@@ -788,22 +840,14 @@ func TestSerializationOfError(t *testing.T) {
 	kv = Any("err", err)
 	kvStr = kv.StringValue()
 	expected = `{"Msg":"custom error","Code":42}`
+	if !fullJSON {
+		expected = `"custom error custom error (code 42)"`
+	}
 	if kvStr != expected {
 		t.Errorf("unexpected:\n%s\nvs:\n%s\n", kvStr, expected)
 	}
 }
 
-func TestToJSON_MarshalError(t *testing.T) {
-	badValue := make(chan int)
-
-	expected := fmt.Sprintf("\"ERR marshaling %v: %v\"", badValue, "json: unsupported type: chan int")
-	actual := toJSON(badValue)
-
-	if actual != expected {
-		t.Errorf("Expected %q, got %q", expected, actual)
-	}
-}
-
 func TestEnvHelp(t *testing.T) {
 	SetDefaultsForClientTools()
 	Config.NoTimestamp = false