AI Prompts for Handling Async Error Propagation

Please review the following async function: [PASTE FUNCTION]. Identify any unhandled errors present in the code and provide a detailed analysis. Specifically, list any missing try-catch blocks, explain how errors are currently being handled, and point out any potential issues with error propagation. Additionally, suggest improvements to ensure that all errors are properly managed and provide examples of how to implement these changes effectively.

Analyze the following code snippet for error propagation: [PASTE CODE]. Determine whether errors are being correctly propagated to the calling functions and explain the mechanisms in place for error handling. Discuss any potential issues you identify, including how errors are caught and whether they are appropriately communicated back to the caller. Additionally, suggest improvements if the current implementation does not adequately handle errors.

Please evaluate the error handling in the following asynchronous function: [PASTE FUNCTION]. Analyze how errors are currently managed, including any try-catch blocks, error logging, or user feedback mechanisms. Identify any potential weaknesses or areas for improvement, such as unhandled promise rejections or lack of informative error messages. Provide specific recommendations for enhancing the robustness of the error handling, and explain how these changes could improve the overall reliability of the function.

Please analyze the following code: [PASTE CODE]. Identify any areas where silent failures may occur, specifically focusing on unhandled asynchronous errors. Provide a detailed explanation of each potential issue you find, including the specific lines of code involved and suggestions for how to handle these errors effectively. Additionally, outline best practices for managing async errors in this context to prevent future occurrences.

Please assess the following async function: [PASTE FUNCTION]. Evaluate whether the error logging is implemented effectively and identify any potential gaps in the current approach. Provide specific recommendations for enhancements that could improve error tracking and handling, including any best practices that should be followed. Additionally, suggest how to structure the logging for better clarity and usefulness in debugging scenarios.

Please review the following function: [PASTE FUNCTION]. Identify all areas where errors may occur and insert appropriate try-catch blocks to handle these exceptions. Ensure that each potential error is caught and logged with a clear message indicating the nature of the error. Additionally, provide suggestions for how to handle each error gracefully, including any fallback mechanisms or user notifications that may be necessary.

Please review the following code: [PASTE CODE] and enhance the error messages present within it. Focus on making each message more informative and actionable for the user. Provide specific suggestions on how to improve clarity, detail, and guidance for resolving the errors. Aim for a format that includes the original message and the revised version, ensuring that the changes enhance the overall user experience and understanding of the issues.

Please modify the following function: [PASTE FUNCTION] to ensure that any errors that occur within it are properly propagated to the calling context. Explain the changes you make and provide examples of how the function behaves before and after the modification. Additionally, include any necessary error handling mechanisms that should be implemented to ensure that the calling context can appropriately respond to these errors. Aim for a clear and concise code structure that maintains readability and functionality.

Please implement fallback logic to handle errors gracefully in the following code: [PASTE CODE]. Ensure that the fallback mechanism provides a user-friendly message and logs the error for further analysis. Describe the specific changes you made to the code, including how the fallback logic is triggered and any additional error handling measures you implemented. Additionally, explain how this improves the overall robustness of the application.

Refactor the following async function to enhance its error handling robustness: [PASTE FUNCTION]. Please provide a detailed explanation of the changes you made and the reasoning behind your approach. Specifically, address how you handle different types of errors, any fallback mechanisms you implement, and how these improvements contribute to the overall reliability of the function. Additionally, include examples of potential error scenarios and how your refactoring mitigates them.

Please execute a series of tests on the following function: [PASTE FUNCTION]. Focus on verifying that all potential errors are handled correctly, including both synchronous and asynchronous scenarios. For each test case, document the expected outcome versus the actual outcome, and provide a summary of any errors that were caught or missed during the tests. Additionally, include recommendations for any further improvements to error handling based on your findings.

Please simulate potential error scenarios in the following code: [PASTE CODE]. Identify and describe at least three different types of errors that could occur during execution. For each error scenario, explain how the existing error handling mechanisms respond and whether they effectively manage the error. Additionally, provide suggestions for improving error handling if necessary, and summarize the overall robustness of the error management in the code.

Please review the error logs generated by the function: [PASTE FUNCTION]. Verify that all handled errors are accurately reflected in the logs. Provide a summary of any discrepancies you find, including the specific errors that were not logged correctly. Additionally, suggest potential improvements to the error handling process to ensure all relevant errors are captured in the future. Format your findings in a clear, structured report.

Please validate the error propagation in the following code: [PASTE CODE]. Analyze how errors are handled and ensure that they are correctly passed through the various functions and components. If you identify any issues or inconsistencies in the error handling process, provide detailed feedback on what needs to be corrected. Additionally, confirm whether the current implementation meets best practices for error propagation in asynchronous code.

Please verify that the fallback logic in the function [PASTE FUNCTION] executes correctly. Run a series of tests to ensure that the fallback is triggered under the appropriate conditions. Document any discrepancies or unexpected behaviors you observe during the execution. Additionally, provide recommendations for any improvements or adjustments needed to ensure the fallback logic operates as intended.

Please draft a new error handling rule for CLAUDE.md that focuses on enforcing proper asynchronous error handling practices. The rule should include specific guidelines on how to catch and manage errors in asynchronous functions, ensuring that errors are logged appropriately and that fallback mechanisms are in place. Additionally, outline the consequences for not adhering to this rule and provide examples of correct and incorrect implementations. Format the rule clearly with headings and bullet points for easy reference.

Help me design a comprehensive template for consistent error logging in asynchronous functions. The template should include sections for the error message, error code, timestamp, function name, parameters passed to the function, and a stack trace. Additionally, provide guidelines on how to categorize errors (e.g., critical, warning, info) and suggestions for follow-up actions based on the error type. Format the template in a clear and organized manner that can be easily adapted for different projects.

Create a comprehensive guide on ensuring error propagation in asynchronous functions. Start by outlining the importance of error handling in async programming and the common pitfalls developers face. Include key steps such as using try-catch blocks, handling promise rejections, and implementing error boundaries. Provide clear examples demonstrating proper error propagation techniques in both JavaScript and Python. Conclude with best practices to prevent recurrence of these errors in future projects.

Please propose a set of naming conventions for asynchronous functions that clearly indicate their error handling status. Include at least five different conventions, explaining the rationale behind each one and how they can help developers quickly understand the error handling approach used in the function. Additionally, provide examples of function names that follow these conventions, and suggest any best practices for implementing these naming conventions in a codebase.

Help me create a comprehensive checklist for reviewing asynchronous error handling during code reviews. The checklist should include key items such as verifying proper error propagation, ensuring that all promises are handled correctly, checking for the use of try-catch blocks in async functions, confirming that error logging is implemented, and validating that fallback mechanisms are in place. Additionally, include items to assess the clarity of error messages and the documentation of error handling strategies. Format the checklist in a clear, bulleted list for easy reference.