local storage handling issue when uploading new files

Oct 13, 2025 by recoveryshake.com 108 views

Introduction

In this bug report, we will be discussing an issue where the API fails to extract text from files after multiple file uploads until the server is restarted. This problem suggests a possible local storage handling issue when uploading new files. We will outline the steps to reproduce the issue, the expected behavior, and the actual behavior observed.

Description of the Issue

When uploading a file, extracting its text, then uploading another file and attempting to extract it, the /extract_text endpoint sometimes returns an internal server error. However, if the server is restarted, the API is able to extract the previously failed file. This suggests a possible local storage handling issue when uploading new files.

Steps to Reproduce

To reproduce this issue, follow these steps:

Step 1: Access the `/upload` endpoint

Access the /upload endpoint to upload a file.

Step 2: Upload a valid image or PDF and extract its text using the `/extract_text` endpoint

Upload a valid image or PDF and extract its text using the /extract_text endpoint.

Step 3: Upload a different file (image or PDF)

Upload a different file (image or PDF).

Step 4: Attempt to extract text from the newly uploaded file using `/extract_text`

Attempt to extract text from the newly uploaded file using /extract_text.

Step 5: Observe that the API sometimes returns an internal error

Observe that the API sometimes returns an internal error.

Step 6: Restart the server and attempt the extraction again

Restart the server and attempt the extraction again.

Step 7: Notice that the previously failed file is now successfully transcribed

Notice that the previously failed file is now successfully transcribed.

Expected Behavior

The API should consistently process text extraction requests without requiring a server restart. Uploading a new file should not interfere with previous or future extraction requests. If a file cannot be processed, the API should return a clear error message rather than failing unexpectedly.

Actual Behavior

The /extract_text endpoint randomly fails with an internal server error when a second file is uploaded. Restarting the server resolves the issue, indicating a possible local storage handling problem.

Severity Level

The severity level of this issue is High (Major functionality not working).

Related Issues (if any)

No related issues have been reported yet.

Conclusion

In conclusion, the API fails to extract text after multiple file uploads until the server is restarted. This issue suggests a possible local storage handling issue when uploading new files. To resolve this issue, we need to investigate and fix the local storage handling problem.

Recommendations

To resolve this issue, we recommend the following:

Investigate the local storage handling issue: Investigate the local storage handling issue to determine the root cause of the problem.
Fix the local storage handling issue: Fix the local storage handling issue to ensure that the API consistently processes text extraction requests without requiring a server restart.
Implement error handling: Implement error handling to return a clear error message if a file cannot be processed rather than failing unexpectedly.

Introduction

In our previous article, we discussed an issue where the API fails to extract text after multiple file uploads until the server is restarted. This problem suggests a possible local storage handling issue when uploading new files. In this Q&A article, we will answer some frequently asked questions related to this issue.

Q: What is the root cause of the issue?

A: The root cause of the issue is a possible local storage handling problem. When uploading a new file, the API fails to update the local storage correctly, leading to inconsistent behavior.

Q: Why does the API fail to extract text after multiple file uploads?

A: The API fails to extract text after multiple file uploads because the local storage handling issue causes the API to lose track of the previously uploaded files. This leads to inconsistent behavior and errors when trying to extract text from the newly uploaded files.

Q: Why does restarting the server resolve the issue?

A: Restarting the server resolves the issue because it clears the local storage and allows the API to start fresh. This ensures that the API has a clean slate and can process text extraction requests consistently.

Q: How can we prevent this issue from occurring in the future?

A: To prevent this issue from occurring in the future, we need to fix the local storage handling issue. This can be done by implementing a robust local storage management system that ensures consistent behavior and updates the local storage correctly.

Q: What are the consequences of not fixing this issue?

A: If we don't fix this issue, it can lead to inconsistent behavior, errors, and frustration for users. It can also lead to data loss and corruption if the API fails to extract text from files correctly.

Q: How can we implement error handling to return a clear error message?

A: To implement error handling, we can use try-catch blocks to catch any errors that occur during text extraction. We can then return a clear error message to the user, indicating the reason for the failure.

Q: What are the benefits of fixing this issue?

A: Fixing this issue will ensure that the API consistently processes text extraction requests without requiring a server restart. This will improve the user experience, reduce errors, and increase the overall reliability of the API.

Q: How can we prioritize this issue?

A: We can prioritize this issue by assigning a high severity level and allocating resources to fix it as soon as possible. We can also involve the development team and stakeholders to ensure that everyone is aware of the issue and its impact.

Conclusion

In conclusion, the API fails to extract text after multiple file uploads until the server is restarted due to a possible local storage handling issue. By fixing this issue, we can ensure that the API consistently processes text extraction requests without requiring a server restart. We can implement error handling to return a clear error message and prioritize this issue by assigning a high severity level and allocating resources to fix it as soon as possible.