`GoTrueClient` Memory Leak

[ghost]

TLDR

This line is causing a memory leak:
https://github.com/supabase/gotrue-js/blob/15c7c8258b2d42d3378be4f7738c728a07523579/src/GoTrueClient.ts#L2040

setInterval will persist even if the object calling it (in this case, GoTrueClient) has been dereferenced. This prevents garbage collection (as setInterval is still holding a reference, even if the user has lost all references) and leads to the memory leak.

A solution seems to have been attempted, but it is not working in (at the very least) React Native, where I encountered this issue:
https://github.com/supabase/gotrue-js/blob/15c7c8258b2d42d3378be4f7738c728a07523579/src/GoTrueClient.ts#L2043

See Also

• the issue confirmed: https://stackoverflow.com/questions/41429030/does-setinterval-inside-an-object-prevent-garbage-collection-when-the-object-is
• potential solution: https://github.com/nbarrow-inspire-labs/bug-demo/blob/main/src/IntervalTimer.ts
  • blocked in React Native: Hermes WeakRef Support in React Native facebook/react-native#42742
• docs: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakRef

History

I originally opened this here (#983) but moved once I discovered the setInterval issue.

Bug report

• I confirm this is a bug with Supabase, not with my own application.
• I confirm I have searched the Docs, GitHub Discussions, and Discord.

Describe the bug

Calling createClient results in a GoTrueClient memory leak on React Native. It may be the entire SupabaseClient, but I only tested with GoTrueClient after noticing massive memory issues. See demo repo and video below.

EDIT!: I have tracked the issue down to this line of code:
https://github.com/supabase/gotrue-js/blob/15c7c8258b2d42d3378be4f7738c728a07523579/src/GoTrueClient.ts#L2040

It looks like setInterval persists even after an object is dereferenced, avoiding garbage collection. Can we transfer this to @supabase/gotrue-js?

To Reproduce

I created a demo repo here. This is an extremely simplistic example; in our production app, we are using a router to navigate and noticed that (navigating between pages) we had memory leaks and supabase clients persisting, even though the page was no longer even being rendered and the supabase client should have been destroyed. I could not post our production app publicly, so I made this simple demo to show how even though I no longer have any reference to the client in my code (since it is created and destroyed after every button press), the auth client still exists and sends ticks in the background.

NOTE: as seen in the video below, after 2 button presses (and about 10 seconds) you can see log messages from two supabase clients (GoTrueClient@0 and GoTrueClient@1). These clients are not referenced anywhere; they were (a) created on a button press, then (b) all reference to them was lost. Garbage collection would usually take care of this (I have let it run for several minutes at a time and still had references; I've ever tried creating hundreds, losing the reference, and all hundreds of them persist for seemingly without end).

Edit: I let the app run, without touching it at all, while writing this bug report (the same one shown in video, uninterrupted) and I was still seeing logs from GoTrueClient@1 (and @0) at 2024-02-28T01:43:36.273Z, which is quite a while after in terms of waiting for some kind of garbage collection to have kicked in (assuming there was not a memory leak, but it clearly seems like there is). Here is a log dump showing the clients persisting for quite some time (untill the process was killed): logs.txt

Expected behavior

Supabase clients should not be persisting when dereferenced; somehow garbage collection is being distorted.

Screenshots

1a6a7d82-4e3e-4979-9ae7-acf2326aba62.mp4

System information

• Version of supabase-js: ^2.39.7

I've been playing with something like this, but it won't work in React Native as there is no support for WeakRef nor the FinalizationRegistry (facebook/react-native#42742):

https://github.com/nbarrow-inspire-labs/bug-demo/blob/main/src/IntervalTimer.ts

I just wanted to bump this and see if there's a potential work-around while ReactNative works on supporting WeakRef, etc? My example is a good starting point but clearly not production ready (until WeakRef finds support).

A pub/sub method might be more desireable:

The static class can act as a publisher, using setInterval once at the static level to emit tick events on a regular pattern. All instantiated instances could then subscribe to the events that the static class publisher is emitting; when the static class emits a tick event, the instances could 'do' the tick function.

This would solve the garbage collection issue, as the subscribers exist independently of the one main (static) publisher; if an instance is due for garbage collection, so too would its event subscriber, allowing instances to be garbage collected while the static class publisher is just always running in the background.

Perhaps a library like https://docs.evt.land/ while supports (perportedly) all JS runtimes.

Is there any updates on this?

[sos0]

Is this only for React Native?

[barrownicholas]

As far as I can tell, it effects non-Deno and non-Node.js environments, because the solution attempted previously only fixes this leak for Deno and Node:
https://github.com/supabase/gotrue-js/blob/15c7c8258b2d42d3378be4f7738c728a07523579/src/GoTrueClient.ts#L2043

For the time being, I think this will work (still testing):

import {useEffect, useState} from "react";
import {createClient} from "@supabase/supabase-js";
import AsyncStorage from "@react-native-async-storage/async-storage";

export const useSupabaseClient = (supabase: {
  url: string;
  keys: {
    anon: string;
  }
}) => {

  // this is important too, to use an initializer function in setState
  const [client] = useState(() => createClient(supabase.url, supabase.keys.anon, {
    auth: {
      storage: AsyncStorage
    }
  }));

  useEffect(() => {
    return () => {
      client.auth.stopAutoRefresh().then(); // this should dump the `Timeout`, eliminating all refs, and allow garbage collection
    }
  }, []);

  return client;
};

The operative line is:

client.auth.stopAutoRefresh().then(); // this should dump the `Timeout`, eliminating all refs, and allow garbage collection

From what I can see, ^ seems to work until Hermes has support for WeakRef... once that happens, I can do a PR for a better fix

[uncvrd]

I'm pretty sure I'm dealing with something similar in Node.JS land. I just migrated my app to Supabase and my memory usage now climbs steadily over time until i get an OOM

Around March 9th, i updated my app to only call supabase.auth.getUser(); when necessary instead of on each request. As you can see the slope of memory usage decreased (but since i still need to call this method for authenticated endpoints, the memory usage still grows...just slower). The steep drops are from app restarts.

I see spikes when there are large batches of supabase.auth.getUser() called. Running a memory heap from a load test shows that getItemAsync() and _acquireLock() are the biggest offenders. I can provide this heap if necessary. Anyone else running in to this problem serverside?

[hf]

Not sure why it's a "memory leak," probably the React Native runtime is a bit bad at tracking this. But, as far as I know, you don't have to use this in React Native. You can call supabase.auth.startAutoRefresh() and supabase.auth.stopAutoRefresh().

Take a look at these docs: https://supabase.com/docs/reference/javascript/auth-startautorefresh

@hf the only memory leak will occur in react runtimes that are not (a) Node.js and (b) Deno because of the way setInterval works: if you hold a reference, this is a "strong" reference that will prevent garbage collection. The problem does not exist because, in Node.js, they have a specific dereferencing feature (https://nodejs.org/api/timers.html#timeoutunref) and same with Deno (https://deno.land/api@v1.41.3?s=Deno.unrefTimer) which Supabase already implements automatically:

https://github.com/supabase/gotrue-js/blob/15c7c8258b2d42d3378be4f7738c728a07523579/src/GoTrueClient.ts#L2043

Basically, in non-Node.js and non-Deno runtimes (like hermes in ReactNative) calls to setInterval that reference objects are enough to prevent garbage collection; even if you lose all references to the object, as in this bug report, the setInterval prevents garbage collection as it counts as a reference (even though you've lost all references to the underlying object itself).

If you see my example above (https://github.com/supabase/gotrue-js/issues/856#issuecomment-1989401929), my temporary fix was already using the stopAutoRefresh as you mention for non-compatible runetimes (utilizing the callback/return feature when useEffect unmounts).

I also have a solution using the WeakRef api to completely fix this on most runtimes, but React Natives hermes engine is not releasing support for WeakRef until Q2/Q3 this year: facebook/react-native#42742 (comment)

[uncvrd]

@nbarrow-inspire-labs i guess I'm a bit confused ...I'm also dealing with a memory leak but I use Supabase in a Node.JS context so it's still affecting me as well, not just in React Native (etc.). Calling .getUser() causes my memory in a Fastify server to steadily increase over time 🤔

@uncvrd can you try the debug option in your createClient (I believe it is as follows):

  const [client] = useState(() => createClient(supabase.url, supabase.keys.anon, {
    auth: {
      debug: true
    }
  }));

Perhaps the logs will give some insight? Also, if you see the number of clients increasing (each log statement indicates which number client it is) then you might be having the exact same issue, but for a different reason.

[uncvrd]

@nbarrow-inspire-labs oh thank you for leading me to the debug option! Yikes, yes, i ran a load test for 45 seconds and it has created 4000+ clients it seems like

@uncvrd yeah you definitely have a memory leak problem (youre correct that 4267 clients were created in your short testing period)... can I see the load test you ran (if it was a simple test repo) or perhaps can you post snipets of how you are creating your supabase clients?