Improve test used to determine if user can connect to plex server to reduce CPU usage

[phobiac]

Describe the bug
This is an old issue and I originally reported it here but I'm copying that information over.

The theory from that error report was that the currently used connection test which calls plex.library.sections() for each user is CPU intensive. It may actually be as simple as the retry logic being too aggressive? Regardless my testing showed that it's this check which is being repeated that was spiking CPU usage on my end.

To Reproduce
I'm not sure how exactly to reproduce it, but I have this issue come up frequently enough with my users that I can at least test potential fixes...

Expected behavior
A more graceful failure if the connection fails that doesn't spike CPU usage.

Actual Behavior
Repeated attempts to perform the test that cause high CPU usage.

Environment Details

• Plex Auto Languages Version: journeyover/plex-auto-languages:main (pulled today to check)
• Plex Server Version: 1.41.3.9314
• Operating System (if applicable): Debian Linux
• Deployment Method (if applicable): Docker

[JourneyOver]

Will take a look at improving the currently used connection test when I have some free time (hopefully this weekend), I sadly won't be able to do any testing myself on this however as I only have one extra user on my plex and I haven't ran into this issue myself ever so I will be relying on you to test any changes I make covering this issue.

I'm wondering if we could just change it to a lightweight test, something like:

@property
def connected(self):
    if self._plex is None:
        return False
    try:
        # Test connection with a lightweight call instead of fetching all sections
        _ = self._plex.library.search(libtype="movie", maxresults=1)
        return True
    except (BadRequest, RequestsConnectionError):
        return False

for example would solve the issue?

I'll shoot you a ping whenever I get some commits out for testing or if you feel like it you could try the above little bit of code by going into the container and apk add nano and go into the plex_server.py file with nano and change said line and could report back on things.

[JourneyOver]

Hey @phobiac

I just pushed up a commit that will hopefully take care of this by testing the connection with a more lightweight call (hopefully) instead of fetching all sections. Do you mind testing it out for me and seeing if you still end up running into this issue or not at any point? You'll need to pull with the :main tag.

I also fixed your comment a tiny bit as you was linking to https://github.com/JourneyDocker/Plex-Auto-Languages/issues instead of the actual issue/comment on RemiRigals repo.

[Zorro92]

Is the purpose of this just to ensure we have a valid token for the server?

[JourneyOver]

@Zorro92 At least from my understanding the purpose of this is to ensure that the main user and any other users of the server are actually connected or are able to connect to the server.

I tried various things myself locally to see if we could instead just change the timing on how often the check is actually done but everything I tried just ended up in failure as the timing on how often the connections where checked never seemed to change, so I'm hoping that with the change I did it at least alleviates things at least a bit.

[JourneyOver]

Hmm so the change I did actually runs into a different crashing issue after a tiny bit (not sure why I wasn't running into it at first when I tried the change but I guess I just didn't wait long enough) due to Failed to get access token for {USER}, so I'm going to revert the code and try some other things out locally and hopefully come up with some kind of solution in the end.

[JourneyOver]

I'm thinking I might have something now, I'll need to do a bit more testing locally to at least make sure I don't run into the error I did above (I'm going to test for a couple hours before I deem it worthy of committing), but if I don't run into the error any then I'll push the code up for further testing from you.

If you want to get to testing right away before I actually push the commit up though the change was just changing:

    def __init__(self, url: str, token: str, session: requests.Session = requests.Session()):
        self._session = session
        self._plex_url = url
        self._plex = self._get_server(url, token, self._session)

    @property
    def connected(self):
        if self._plex is None:
            return False
        try:
            _ = self._plex.library.sections()
            return True
        except (BadRequest, RequestsConnectionError):
            return False

to:

    def __init__(self, url: str, token: str, session: requests.Session = requests.Session()):
        self._session = session
        self._plex_url = url
        self._plex = self._get_server(url, token, self._session)
        self._last_connection_check = None
        self._connection_check_interval = timedelta(minutes=5)  # Cache connection status for 5 minutes

    @property
    def connected(self):
        if self._plex is None:
            logger.debug("No Plex instance available (self._plex is None)")
            return False
        if self._last_connection_check is not None:
            elapsed_time = datetime.now() - self._last_connection_check
            logger.debug(f"Time since last connection check: {elapsed_time}")
            if elapsed_time < self._connection_check_interval:
                remaining_time = self._connection_check_interval - elapsed_time
                logger.debug(f"Using cached result. Remaining time for next check: {remaining_time}")
                return self._plex is not None
        try:
            logger.debug("Attempting to fetch library sections from Plex")
            sections = self._plex.library.sections()
            if sections:
                logger.debug(f"Sections retrieved: {len(sections)} found. Verifying first section.")
                _ = sections[0]
                self._last_connection_check = datetime.now()
                logger.debug("Connection verified successfully")
                return True
            logger.debug("No sections found in the Plex library")
            return False
        except (BadRequest, RequestsConnectionError, IndexError) as e:
            logger.debug(f"Connection check failed with known exception: {type(e).__name__}: {str(e)}")
            self._last_connection_check = datetime.now()
            return False
        except Exception as e:
            logger.warning(f"Unexpected error during connection check: {type(e).__name__}: {str(e)}")
            self._last_connection_check = datetime.now()
            return False

It has debug logging in the code as well as the actual changes, as I wanted to check and see if it was actually going to be using the _connection_check_interval and the cached result any and at least from what I can tell it does.

May not be the best way to do things, but it's just something quick for now until a better solution in the future can be thought of.

[JourneyOver]

Alright several hours later of testing and so far I at least haven't ran into any errors myself with the new code so I've gone ahead and pushed it on up. Feel free to run some testing once they are pushed to ghcr and dockerhub @phobiac to see if it solves this issue or not.

Also going to finally label this dang issue as well now xD

[phobiac]

Downloading this update now! I'll report back this evening after I've given things a chance to run for a while and see how the logs go.

For posterity, I'm currently using this config:

plexautolanguages:
  update_level: "show"       # Options: "show" (default), "season"
  update_strategy: "all"     # Options: "all" (default), "next"
  trigger_on_play: true       # Update language when playing an episode
  trigger_on_scan: true       # Update language when new files are scanned
  trigger_on_activity: true  # Update language when navigating Plex (experimental)

[JourneyOver]

Welp this setting trigger_on_activity being enabled is def going to be the biggest cause of why you are having high CPU usage as it is noted in the config.example.yaml:

  # Whether or not navigating the Plex library should trigger a language update, defaults to 'false'
  # Only the Plex web client and the Plex for Windows app support this feature
  # Set this to 'true' only if you want to perform changes whenever the default track of an episode is updated, even when the episode is not played.
  # Setting this parameter to 'true' can result in higher resource usage.
  trigger_on_activity: false

It's got me wondering if I should just make a special case for when that setting is set to true or something..

[phobiac]

I was going for testing the worst case scenario, and can confirm there's still high CPU usage with this setting. Let me turn trigger on activity off (that's how I typically run) and try it again.

[JourneyOver]

From what I understand, having the setting turned off, even with the old method, shouldn't be causing excessively high CPU usage unless you have an egregious number of users that access your plex. I wish I knew where the timer controlling the connected check is located so I could adjust it. Unfortunately, every method I've tried to increase the interval between checks has failed, and I haven't been able to find where in the code this is actually managed.