Esistono algoritmi genetici per le funzioni Python per trovare l'elemento più lungo in un documento JSON?

Sto tentando di registrare un messaggio di errore JSON sulla piattaforma di Cloud Logging di Google. Sfortunatamente, il messaggio di dimensione massima che puoi registrare è 8000 byte e alcuni dei documenti JSON che voglio registrare sono più grandi di questo. Invece di tagliare semplicemente la stringa JSON, preferirei rimuovere iterativamente il "campo" più grande (e sostituirlo con un indicatore come "REMOVED") finché il documento non è al limite.

Ho qualcosa che funziona essenzialmente attraverso la versione deserializzata del documento, campo dopo campo, tenendo traccia del valore più lungo trovato finora. Questo metodo non riesce a tenere traccia di dove nel grafico dell'oggetto si trova questo elemento, ma sono in grado di eseguire una semplice sostituzione sulla stringa JSON in seguito.

Sebbene questo codice faccia il lavoro per quello di cui ho bisogno, sono comunque interessato a sapere se esiste un algoritmo esistente o funzioni Python incorporate che potrebbero essere applicate in questa situazione.

import json
import sys


class RecursiveApply:
    def __init__(self, function_to_apply):
        self.function_to_apply = function_to_apply

    def process_item(self, current, item):
        if isinstance(item, list):
            for i in item:
                current = self.process_item(current, i)
            return current
        elif isinstance(item, dict):
            for k, v in item.items():
                current = self.process_item(current, v)
            return current
        else:
            return self.function_to_apply(current, item)


class GetBigger:
    def __init__(self, ignore_value):
        self.ignore = ignore_value

    def get_bigger(self, biggest, obj):
        json_obj = json.dumps(obj)
        size = sys.getsizeof(json_obj)
        if (biggest is None or size > biggest[0]) and obj != self.ignore:
            return size, json_obj
        else:
            return biggest


class LimitJSON:
    def __init__(self, find_biggest, replace_val):
        self.find_biggest = find_biggest
        self.replace_val = replace_val

    def limit_JSON(self, max_len, json_string):
        current = None
        while len(json_string) > max_len:
            biggest_item = self.find_biggest(current, json.loads(json_string))
            if biggest_item:
                json_string = json_string.replace(biggest_item[1], '"' + REPLACE_VAL + '"')
            else:
                break
        return json_string

REPLACE_VAL = '*REMOVED*'
gb = GetBigger(REPLACE_VAL)
ra = RecursiveApply(gb.get_bigger)
lj = LimitJSON(ra.process_item, REPLACE_VAL)


original_data = ['long array item', {'item1': 'dict item', 'item 2': 'longer dict item'}, 'little item', 123123123123123123123123123]
json_string = json.dumps(original_data)
processed_json = lj.limit_JSON(100, json_string)
print(processed_json)

# RESULT ->
# ["long array item", {"item 2": "*REMOVED*", "item1": "dict item"}, "little item", "*REMOVED*"]