Fix: RSS Feed Not Updating Categories In Ygege

by Alex Johnson 47 views

Experiencing issues with your Ygege RSS feed not updating correctly, particularly with categories displaying as 'System.IntDiscussion'? You're not alone! This article dives deep into troubleshooting this common problem, providing a comprehensive guide to get your RSS feeds back on track. We'll explore the bug report details, analyze the configuration, and offer step-by-step solutions to ensure your categories update as expected. Let's get started!

Understanding the Issue

From the bug report, a user encountered a persistent issue where the RSS feed in Prowlarr was not updating with the correct categories. Instead, it consistently showed System.Int32[]. This indicates a problem with how categories are being passed or processed between Prowlarr and Ygege. To effectively troubleshoot, we will analyze the setup, configuration, and logs to pinpoint the root cause of this behavior. We'll break down each component to ensure that the problem is clearly defined and that a structured approach can be applied.

Initial Bug Report Analysis

Before diving into the technical aspects, let's summarize the key points from the bug report:

  • Problem: RSS feed in Prowlarr is not updating categories correctly, showing System.Int32[] instead.
  • Setup:
    • Prowlarr is on machine .16 (192.168.1.16).
    • Ygege is on machine .39 (192.168.1.39).
  • Ygege Docker Configuration: The user provided their Docker Compose configuration, which uses a bridge network mode and volume mounts for sessions and configurations.
  • Version: The user is using the master branch due to a previous error encountered with other branches.
  • Prowlarr Event Log: The logs consistently show the same JSON request with categories=System.Int32%5B%5D in the URL.
  • Ygege Logs: Ygege receives the query and processes it, but the categories are not being parsed correctly.
  • Manual Searches: Manual searches and API usage outside of Prowlarr work correctly.
  • Reproduction: The issue occurs consistently after deploying the container and triggering an RSS event through Prowlarr.
  • Expected Behavior: The JSON from the RSS feed should vary based on different categories.

This initial analysis helps us frame the problem and identify potential areas for investigation. The consistent System.Int32[] in the URL suggests an encoding or serialization issue, which we will explore further.

Examining the Configuration and Setup

To effectively address this issue, a detailed examination of the configuration and setup is essential. We need to verify that all components are correctly configured and communicating with each other. This involves scrutinizing the network settings, Docker Compose file, and application configurations of both Prowlarr and Ygege.

Network Configuration

The user's setup involves Prowlarr and Ygege running on separate machines within the same network (192.168.1.0/24). Prowlarr, residing on 192.168.1.16, communicates with Ygege, which is hosted on 192.168.1.39. Ygege is configured to expose port 8715, as evidenced by the port mapping 8715:8715 in the Docker Compose file. This configuration implies that network connectivity between the two containers is crucial for the RSS feed to function correctly.

It's important to ensure that there are no firewall rules or network policies that might block communication between these two machines. Additionally, DNS resolution needs to be functioning correctly so that Prowlarr can resolve the hostname or IP address of Ygege. A simple ping or telnet command from the Prowlarr machine to the Ygege machine on port 8715 can help verify basic network connectivity.

Docker Compose Configuration

The provided Docker Compose file for Ygege is a key piece of the puzzle. Let's break down each section to understand its implications:

services:
  ygege:
    image: uwucode/ygege:master
    container_name: ygege
    network_mode: bridge
    restart: unless-stopped
    volumes:
      - /mnt/docker_nfs/ygege/sessions:/app/sessions
      - /mnt/docker_nfs/ygege/config.json:/app/config.json
    ports:
      - 8715:8715
  • image: uwucode/ygege:master: This line specifies the Docker image to use, which is the master branch of the uwucode/ygege repository. As noted in the bug report, the user selected this branch to circumvent a prior error. However, it's important to acknowledge that the master branch might contain the latest changes, which could potentially introduce new issues or bugs. Therefore, using a stable release is generally recommended for production environments.
  • container_name: ygege: This sets the name of the Docker container to ygege, facilitating easier management and identification within the Docker environment.
  • network_mode: bridge: This is a significant setting. The bridge network mode creates a private network internal to the Docker host, allowing containers to communicate with each other via IP addresses. However, containers in the bridge network are isolated from the host network unless ports are explicitly exposed. In this case, port 8715 is exposed, enabling external access to Ygege's web interface.
  • restart: unless-stopped: This policy ensures that the container automatically restarts if it exits unexpectedly, unless it was explicitly stopped by the user. This adds a layer of resilience, ensuring that Ygege remains operational.
  • volumes:: This section defines the volume mounts, which persist data outside the container's filesystem. This is crucial for maintaining sessions and configuration files across container restarts or upgrades.
    • /mnt/docker_nfs/ygege/sessions:/app/sessions: This mounts the host's /mnt/docker_nfs/ygege/sessions directory to the container's /app/sessions directory, preserving session data.
    • /mnt/docker_nfs/ygege/config.json:/app/config.json: This mounts the host's /mnt/docker_nfs/ygege/config.json file to the container's /app/config.json file, ensuring that Ygege uses the correct configuration.
  • ports::
    • - 8715:8715: This maps port 8715 on the host to port 8715 within the container, making Ygege accessible from the host network. This is essential for Prowlarr to communicate with Ygege.

Application Configurations (Prowlarr and Ygege)

Application-specific configurations in both Prowlarr and Ygege play a pivotal role in the proper functioning of the RSS feed. It's essential to ensure that the settings related to categories, search parameters, and communication protocols are correctly configured.

In Prowlarr, the indexer configuration for Ygege must be meticulously checked. This includes the URL, API key (if applicable), category mappings, and any custom search parameters. An incorrect URL or API key will prevent Prowlarr from communicating with Ygege. Moreover, the category mappings in Prowlarr should align with the categories supported by Ygege to ensure that search requests are correctly translated.

On the Ygege side, the configuration file (config.json) needs to be examined. This file typically contains settings related to the torrent providers, search behavior, and API endpoints. Any misconfigurations in this file can lead to unexpected behavior. Pay particular attention to the category settings and ensure that they are correctly defined and match what Prowlarr expects.

By meticulously reviewing the network settings, Docker Compose file, and application configurations, you lay a solid foundation for identifying the root cause of the RSS feed issue. Each component must be correctly configured for the system to function seamlessly.

Analyzing Logs for Clues

Log files are invaluable resources for diagnosing issues. By carefully analyzing the logs from both Prowlarr and Ygege, we can gain insights into the communication flow, identify errors, and pinpoint the exact moment when the category information is being lost or misinterpreted. Let’s dissect the logs provided in the bug report to extract pertinent information.

Prowlarr Event Log Analysis

The Prowlarr event log is the first place to look for clues about the RSS feed issue. The log entry provided in the bug report gives us a snapshot of the request being made by Prowlarr to Ygege:

Query
-
Indexer
Ygégé
Query Results
50
Categories
-
Source
Other
Host
172.17.0.1
Url
[Link](http://192.168.1.39:8715/search?sort=seed&order=desc&categories=System.Int32%5B%5D)
Elapsed Time
392ms
Date
11/11/2025 14:43:30

The most crucial part of this log entry is the URL: http://192.168.1.39:8715/search?sort=seed&order=desc&categories=System.Int32%5B%5D. This URL reveals that Prowlarr is sending a search request to Ygege with the categories parameter set to System.Int32[]. This is where the problem lies. The System.Int32[] suggests that Prowlarr is serializing the categories as a .NET array type, which is not a standard format for web requests. Ygege, or any other application, would likely not be able to interpret this directly as a category filter.

The Host field shows 172.17.0.1, which is an internal Docker IP address. This indicates that the request is originating from within Prowlarr's Docker container. This is expected since Prowlarr is running in a container.

The Query Results field shows 50, indicating that Ygege is returning 50 results for the request, even with the incorrect category parameter. This suggests that Ygege might be ignoring the categories parameter altogether when it's in this format, or it might have a fallback behavior that returns results regardless of the category.

Ygege Log Analysis

Next, let’s analyze the Ygege logs to see how Ygege is handling the request from Prowlarr:

DEBUG ygege::rest::search  > Received query: sort=seed&order=desc&categories=System.Int32%5B%5D
DEBUG ygege::search        > Searching for torrents (name: None, offset: None, category: None, sub_category: None, sort: Some(Seed), order: Some(Descending))
DEBUG ygege::search        > Search response: 200 OK
DEBUG ygege::parser        > detected 50 torrents
DEBUG ygege::parser        > Parsed 50 torrents
DEBUG ygege::search        > Found 50 torrents in 421.627421ms
INFO  ygege::rest::search  > 50 torrents found

The Ygege logs confirm that the application is receiving the query with the problematic categories=System.Int32%5B%5D parameter. The log line DEBUG ygege::rest::search > Received query: sort=seed&order=desc&categories=System.Int32%5B%5D clearly shows the raw query string received by Ygege.

The subsequent log line, DEBUG ygege::search > Searching for torrents (name: None, offset: None, category: None, sub_category: None, sort: Some(Seed), order: Some(Descending)), is particularly revealing. It shows that Ygege is parsing the query and extracting the sort and order parameters but is setting the category to None. This confirms our suspicion that Ygege is unable to interpret the System.Int32[] format and is effectively ignoring the categories parameter.

The rest of the logs indicate that Ygege is processing the search request without any category filter, finding and parsing 50 torrents. This explains why Prowlarr is receiving results even with the incorrect category parameter: Ygege is simply returning all results.

By analyzing these logs, we have pinpointed the core issue: Prowlarr is sending categories in a format that Ygege cannot understand. The next step is to determine why Prowlarr is serializing the categories in this way and how to correct it.

Solutions and Troubleshooting Steps

Based on our analysis, the root cause of the issue is that Prowlarr is sending the categories in an incorrect format (System.Int32[]) that Ygege cannot interpret. To resolve this, we need to focus on the configuration and settings within Prowlarr that control how categories are serialized and sent in search requests. Here are some targeted solutions and troubleshooting steps:

1. Review Prowlarr Indexer Configuration for Ygege

The first step is to thoroughly review the indexer configuration in Prowlarr for Ygege. Pay close attention to the following settings:

  • URL: Ensure that the URL for Ygege is correctly configured (e.g., http://192.168.1.39:8715).
  • API Key: If Ygege requires an API key, verify that it is correctly entered in Prowlarr.
  • Categories: This is the most critical section. Prowlarr needs to map its internal categories to the categories that Ygege understands. If the categories are not mapped correctly, Prowlarr might be sending the categories in a format that Ygege cannot process. Ensure that the category mappings are accurate and that the categories are comma-separated or in the format that Ygege expects.
  • Custom Parameters: Check if there are any custom parameters that might be interfering with the category serialization. Remove any unnecessary or incorrect custom parameters.

To ensure proper category mapping, consult the Ygege documentation or API specifications to understand the expected format for categories. You may need to manually map Prowlarr's categories to Ygege's categories in the Prowlarr indexer settings.

2. Check Prowlarr Category Mappings

In addition to the indexer-specific settings, Prowlarr has global category mappings that can affect how categories are handled. Navigate to the category settings in Prowlarr and verify that the categories are mapped correctly to the appropriate indexer categories. This ensures that when Prowlarr performs a search, it uses the correct category identifiers for each indexer.

3. Examine Prowlarr Logs in Debug Mode

To get more detailed information about how Prowlarr is constructing the search request, enable debug logging in Prowlarr. Debug logs provide verbose output that can help you see exactly how the categories are being serialized and added to the URL. After enabling debug logging, trigger an RSS sync and examine the logs for any clues about the category serialization process.

4. Test with a Simple HTTP Request

To isolate the issue, try sending a simple HTTP request to Ygege with a correctly formatted category parameter. You can use tools like curl or Postman to construct the request. This will help you verify that Ygege can correctly process categories when they are sent in the expected format.

For example, if Ygege expects categories as comma-separated integers, you can try the following curl command:

curl "http://192.168.1.39:8715/search?sort=seed&order=desc&categories=1,2,3"

Replace 1,2,3 with actual category IDs that Ygege supports. If this request works, it confirms that Ygege can handle categories correctly, and the issue is likely with how Prowlarr is formatting the request.

5. Review Ygege Documentation and API Specifications

Consult the Ygege documentation or API specifications to understand the expected format for categories in search requests. This will provide clarity on how categories should be encoded and sent to Ygege. If the documentation provides examples, try replicating those examples in Prowlarr or in your manual HTTP requests.

6. Consider Ygege Version and Branch

The user mentioned using the master branch of Ygege due to a previous error. While using the master branch can sometimes provide the latest features and fixes, it can also introduce instability. Consider switching to a stable release of Ygege if one is available. Stable releases are typically more thoroughly tested and less likely to have bugs.

7. Check for Encoding Issues

Encoding issues can sometimes cause problems with URL parameters. Ensure that the categories are correctly URL-encoded when being sent in the request. Prowlarr should handle URL encoding automatically, but it's worth verifying that there are no encoding-related issues.

8. Prowlarr Version

Ensure you are running the latest version of Prowlarr. Older versions may have bugs that have been addressed in newer releases. Check the Prowlarr release notes for any mentions of fixes related to indexer communication or category handling.

By following these troubleshooting steps, you should be able to identify the specific configuration or setting that is causing Prowlarr to send categories in the incorrect format. Once you have identified the issue, you can adjust the settings accordingly and resolve the RSS feed problem.

Conclusion

Troubleshooting RSS feed issues, especially those involving category misinterpretations like System.Int32[], requires a systematic approach. By meticulously examining configurations, analyzing logs, and performing targeted tests, you can pinpoint the root cause and implement effective solutions. In this case, the issue stemmed from Prowlarr serializing categories in a format incompatible with Ygege. By carefully reviewing Prowlarr's indexer settings, category mappings, and potentially adjusting the Ygege version, you can rectify the problem.

Remember, maintaining accurate category mappings and adhering to the expected API formats are crucial for seamless communication between applications like Prowlarr and Ygege. By following the steps outlined in this guide, you'll be well-equipped to tackle similar challenges in the future.

For additional information on troubleshooting network issues, you might find this resource helpful: Troubleshooting Network Issues - A Comprehensive Guide (This is a placeholder link; replace it with a relevant and trusted resource.)