fix: use better size calculation

Author: hlubek

collector/db_query_collector.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"database/sql/driver"
 	"time"
+
+	"github.com/networkteam/devlog/internal/utils"
 )
 
 // DBQuery represents a database query execution record
@@ -27,8 +29,15 @@ func (q DBQuery) Size() uint64 {
 	size := uint64(100) // base struct overhead
 	size += uint64(len(q.Query))
 	size += uint64(len(q.Language))
-	// Estimate 50 bytes per arg (name + value)
-	size += uint64(len(q.Args) * 50)
+	// Calculate actual size of arguments using reflection
+	for _, arg := range q.Args {
+		size += uint64(len(arg.Name))
+		size += 8 // Ordinal int field
+		argSize := utils.SizeOf(arg.Value)
+		if argSize > 0 {
+			size += uint64(argSize)
+		}
+	}
 	return size
 }
 

docs/screenshot.png

@@ -0,0 +1,170 @@
+// Package utils provides utility functions for the devlog package.
+//
+// The size calculation code in this file is based on github.com/DmitriyVTitov/size
+// Original source: https://github.com/DmitriyVTitov/size
+//
+// MIT License
+//
+// Copyright (c) 2020 DmitriyVTitov
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+package utils
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+// SizeOf returns the size of 'v' in bytes.
+// If there is an error during calculation, SizeOf returns -1.
+func SizeOf(v any) int {
+	// Cache with every visited pointer so we don't count two pointers
+	// to the same memory twice.
+	cache := make(map[uintptr]bool)
+	return sizeOf(reflect.Indirect(reflect.ValueOf(v)), cache)
+}
+
+// sizeOf returns the number of bytes the actual data represented by v occupies in memory.
+// If there is an error, sizeOf returns -1.
+func sizeOf(v reflect.Value, cache map[uintptr]bool) int {
+	switch v.Kind() {
+
+	case reflect.Array:
+		sum := 0
+		for i := 0; i < v.Len(); i++ {
+			s := sizeOf(v.Index(i), cache)
+			if s < 0 {
+				return -1
+			}
+			sum += s
+		}
+
+		return sum + (v.Cap()-v.Len())*int(v.Type().Elem().Size())
+
+	case reflect.Slice:
+		// return 0 if this node has been visited already
+		if cache[v.Pointer()] {
+			return 0
+		}
+		cache[v.Pointer()] = true
+
+		sum := 0
+		for i := 0; i < v.Len(); i++ {
+			s := sizeOf(v.Index(i), cache)
+			if s < 0 {
+				return -1
+			}
+			sum += s
+		}
+
+		sum += (v.Cap() - v.Len()) * int(v.Type().Elem().Size())
+
+		return sum + int(v.Type().Size())
+
+	case reflect.Struct:
+		sum := 0
+		for i, n := 0, v.NumField(); i < n; i++ {
+			s := sizeOf(v.Field(i), cache)
+			if s < 0 {
+				return -1
+			}
+			sum += s
+		}
+
+		// Look for struct padding.
+		padding := int(v.Type().Size())
+		for i, n := 0, v.NumField(); i < n; i++ {
+			padding -= int(v.Field(i).Type().Size())
+		}
+
+		return sum + padding
+
+	case reflect.String:
+		s := v.String()
+		if len(s) == 0 {
+			return int(v.Type().Size())
+		}
+		// Use unsafe.StringData (Go 1.20+) instead of deprecated reflect.StringHeader
+		dataPtr := uintptr(unsafe.Pointer(unsafe.StringData(s)))
+		if cache[dataPtr] {
+			return int(v.Type().Size())
+		}
+		cache[dataPtr] = true
+		return len(s) + int(v.Type().Size())
+
+	case reflect.Ptr:
+		// return Ptr size if this node has been visited already (infinite recursion)
+		if cache[v.Pointer()] {
+			return int(v.Type().Size())
+		}
+		cache[v.Pointer()] = true
+		if v.IsNil() {
+			return int(reflect.New(v.Type()).Type().Size())
+		}
+		s := sizeOf(reflect.Indirect(v), cache)
+		if s < 0 {
+			return -1
+		}
+		return s + int(v.Type().Size())
+
+	case reflect.Bool,
+		reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
+		reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Int, reflect.Uint,
+		reflect.Chan,
+		reflect.Uintptr,
+		reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128,
+		reflect.Func:
+		return int(v.Type().Size())
+
+	case reflect.Map:
+		// return 0 if this node has been visited already (infinite recursion)
+		if cache[v.Pointer()] {
+			return 0
+		}
+		cache[v.Pointer()] = true
+		sum := 0
+		keys := v.MapKeys()
+		for i := range keys {
+			val := v.MapIndex(keys[i])
+			// calculate size of key and value separately
+			sv := sizeOf(val, cache)
+			if sv < 0 {
+				return -1
+			}
+			sum += sv
+			sk := sizeOf(keys[i], cache)
+			if sk < 0 {
+				return -1
+			}
+			sum += sk
+		}
+		// Include overhead due to unused map buckets.  10.79 comes
+		// from https://golang.org/src/runtime/map.go.
+		return sum + int(v.Type().Size()) + int(float64(len(keys))*10.79)
+
+	case reflect.Interface:
+		return sizeOf(v.Elem(), cache) + int(v.Type().Size())
+
+	case reflect.Invalid:
+		return 0
+	}
+
+	return -1
+}

internal/utils/size.go

@@ -0,0 +1,134 @@
+// Tests adapted from github.com/DmitriyVTitov/size
+// Original source: https://github.com/DmitriyVTitov/size/blob/master/size_test.go
+package utils
+
+import (
+	"testing"
+)
+
+func TestSizeOf(t *testing.T) {
+	tests := []struct {
+		name string
+		v    any
+		want int
+	}{
+		{
+			name: "Array",
+			v:    [3]int32{1, 2, 3}, // 3 * 4  = 12
+			want: 12,
+		},
+		{
+			name: "Slice",
+			v:    make([]int64, 2, 5), // 5 * 8 + 24 = 64
+			want: 64,
+		},
+		{
+			name: "String",
+			v:    "ABCdef", // 6 + 16 = 22
+			want: 22,
+		},
+		{
+			name: "Map",
+			// (8 + 3 + 16) + (8 + 4 + 16) = 55
+			// 55 + 8 + 10.79 * 2 = 84
+			v:    map[int64]string{0: "ABC", 1: "DEFG"},
+			want: 84,
+		},
+		{
+			name: "Struct",
+			v: struct {
+				slice     []int64
+				array     [2]bool
+				structure struct {
+					i int8
+					s string
+				}
+			}{
+				slice: []int64{12345, 67890}, // 2 * 8 + 24 = 40
+				array: [2]bool{true, false},  // 2 * 1 = 2
+				structure: struct {
+					i int8
+					s string
+				}{
+					i: 5,     // 1
+					s: "abc", // 3 * 1 + 16 = 19
+				}, // 20 + 7 (padding) = 27
+			}, // 40 + 2 + 27 = 69 + 6 (padding) = 75
+			want: 75,
+		},
+		{
+			name: "Nil",
+			v:    nil,
+			want: 0,
+		},
+		{
+			name: "Int64",
+			v:    int64(42),
+			want: 8,
+		},
+		{
+			name: "Float64",
+			v:    float64(3.14),
+			want: 8,
+		},
+		{
+			name: "Bool",
+			v:    true,
+			want: 1,
+		},
+		{
+			name: "ByteSlice",
+			v:    []byte("hello world"), // 11 + 24 = 35
+			want: 35,
+		},
+		{
+			name: "EmptyString",
+			v:    "",
+			want: 16, // just the string header
+		},
+		{
+			name: "LargeByteSlice",
+			v:    make([]byte, 1000), // 1000 + 24 = 1024
+			want: 1024,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := SizeOf(tt.v); got != tt.want {
+				t.Errorf("SizeOf() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestSizeOf_Pointer(t *testing.T) {
+	s := "test"
+	ptr := &s
+
+	// SizeOf uses reflect.Indirect at the top level, so it measures
+	// the dereferenced value: 4 (string data) + 16 (string header) = 20
+	got := SizeOf(ptr)
+	want := 20
+	if got != want {
+		t.Errorf("SizeOf(ptr) = %v, want %v", got, want)
+	}
+}
+
+func TestSizeOf_CircularReference(t *testing.T) {
+	type Node struct {
+		Value int
+		Next  *Node
+	}
+
+	// Create a circular reference
+	a := &Node{Value: 1}
+	b := &Node{Value: 2}
+	a.Next = b
+	b.Next = a
+
+	// Should not panic or infinite loop
+	got := SizeOf(a)
+	if got < 0 {
+		t.Errorf("SizeOf() returned error for circular reference: %v", got)
+	}
+}