Function NormalizeNestedJSONForNoise

pkg/matcher/utils.go:1742–1780

NormalizeNestedJSONForNoise rewrites a JSON string so that any string fields which themselves contain JSON are parsed into real JSON objects/arrays. It only does this for fields that are hinted by the noise configuration, i.e. when noise keys contain dotted paths like "json_response.timestamp". Thi

(raw string, noise map[string][]string, log *zap.Logger)

// If raw is not JSON, noise is empty, or any error occurs, it returns raw
// unchanged so it is safe to call in all conditions.
func NormalizeNestedJSONForNoise(raw string, noise map[string][]string, log *zap.Logger) string {
	if raw == "" || len(noise) == 0 {
		return raw
	}
	// Fast rejection: not JSON at all → nothing to normalize
	if !json.Valid([]byte(raw)) {
		return raw
	}

	// Collect "root" keys from noise that indicate nested paths.
	// Example: "json_response.timestamp" → root "json_response".
	rootKeys := make(map[string]bool)
	for k := range noise {
		parts := strings.SplitN(k, ".", 2)
		if len(parts) > 1 {
			root := strings.ToLower(parts[0])
			rootKeys[root] = true
		}
	}
	if len(rootKeys) == 0 {
		// No dotted paths → no need to rewrite nested JSON
		return raw
	}

	var v interface{}
	if err := json.Unmarshal([]byte(raw), &v); err != nil {
		utils.LogError(log, err, "failed to unmarshal decoded gRPC data for normalization")
		return raw
	}

	normalizeNestedJSONValue(v, rootKeys)

	buf, err := json.Marshal(v)
	if err != nil {
		utils.LogError(log, err, "failed to re-marshal decoded gRPC data after normalization")
		return raw
	}
	return string(buf)
}

// normalizeNestedJSONValue walks the parsed JSON value and replaces any
// string fields whose key is in rootKeys and whose value is itself valid