jsoncrunch.go

package tok

import (
	"encoding/json"
	"hash/fnv"
	"math/rand"
	"strings"
)

// CompressJSON samples large JSON arrays, keeping error/failure items,
// first 2, last 2, and a random sample of the middle. If maxItems <= 0,
// defaults to 20. Non-array input is returned unchanged.
func CompressJSON(text string, maxItems int) string {
	if maxItems <= 0 {
		maxItems = 20
	}
	text = strings.TrimSpace(text)
	var arr []json.RawMessage
	if err := json.Unmarshal([]byte(text), &arr); err != nil || len(arr) == 0 {
		return text
	}
	if len(arr) <= maxItems {
		return text
	}

	keep := make(map[int]bool)
	// first 2, last 2
	for i := 0; i < 2 && i < len(arr); i++ {
		keep[i] = true
	}
	for i := len(arr) - 2; i < len(arr); i++ {
		if i >= 0 {
			keep[i] = true
		}
	}
	// error/failure items
	for i, raw := range arr {
		s := strings.ToLower(string(raw))
		if strings.Contains(s, "error") || strings.Contains(s, "failure") || strings.Contains(s, "fail") {
			keep[i] = true
		}
	}
	// random sample from middle to fill up to maxItems (deterministic via content hash)
	if len(keep) < maxItems {
		var middle []int
		for i := 2; i < len(arr)-2; i++ {
			if !keep[i] {
				middle = append(middle, i)
			}
		}
		h := fnv.New64a()
		h.Write([]byte(text))
		rng := rand.New(rand.NewSource(int64(h.Sum64())))
		rng.Shuffle(len(middle), func(i, j int) { middle[i], middle[j] = middle[j], middle[i] })
		need := maxItems - len(keep)
		if need > len(middle) {
			need = len(middle)
		}
		for _, i := range middle[:need] {
			keep[i] = true
		}
	}

	var result []json.RawMessage
	for i := 0; i < len(arr); i++ {
		if keep[i] {
			result = append(result, arr[i])
		}
	}
	out, _ := json.Marshal(result)
	return string(out)
}