Check failed: static_cast<int64_t>(u_.json_obj.cons.bytes_used) >= size

[kostasrim]

How to reproduce:

async def test_bug(df_factory: DflyInstanceFactory):                                                                                                                                                               
    master = df_factory.create(proactor_threads=2, serialization_max_chunk_size=1)                                                                                                                                 
    replicas = [                                                                                                                                                                                                   
        df_factory.create(proactor_threads=2)                                                                                                                                                                      
        for i in range(2)                                                                                                                                                                                          
    ]                                                                                                                                                                                                              
                                                                                                                                                                                                                   
    # Start instances and connect clients                                                                                                                                                                          
    df_factory.start_all([master] + replicas)                                                                                                                                                                      
    c_master = master.client()                                                                                                                                                                                     
    c_replicas = [replica.client() for replica in replicas]                                                                                                                                                        
                                                                                                                                                                                                                   
    total = 100000                                                                                                                                                                                                 
    await c_master.execute_command(f"DEBUG POPULATE {total} tmp 1000 TYPE SET ELEMENTS 100")                                                                                                                       
                                                                                                                                                                                                                   
    thresehold = 25000                                                                                                                                                                                             
    for i in range(thresehold):                                                                                                                                                                                    
        rand = random.randint(1, 4)                                                                                                                                                                                
        await c_master.execute_command(f"EXPIRE tmp:{i} {rand} NX")                                                                                                                                                
                                                                                                                                                                                                                   
    seeder = StaticSeeder(key_target=100_000)                                                                                                                                                                      
    fill_task = asyncio.create_task(seeder.run(master.client()))                                                                                                                                                   
                                                                                                                                                                                                                   
    for replica in c_replicas:                                                                                                                                                                                     
        await replica.execute_command(f"REPLICAOF LOCALHOST {master.port}")                                                                                                                                        
                                                                                                                                                                                                                   
    async with async_timeout.timeout(240):                                                                                                                                                                         
        await wait_for_replicas_state(*c_replicas)                                                                                                                                                                 
                                                                                                                                                                                                                   
    await fill_task               

[kostasrim]

@romange it's important + urgent. We trigger a check failed in json so something could be off with our mem tracking

[romange]

I see here a test and a bug. What should I understand from this? :)
Can you please explain why do you think it's important and urgent?

[kostasrim]

Because check fails are hard crashes and can cause service disruption and I would like this fixed on the next version. I suspect we have a bug around memory tracking and I would like to avoid crashes in production

[kostasrim]

If you still think it's not that important I am happy to remove the labels

[romange]

every crash bug is important but we estimate urgency based on empirical evidence whether this bug does really affect anything.

[kostasrim]

gotcha, removing it then