Error handling in production in Flask - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Flask function used to render templates for error pages.

Flask

from flask import Flask, [1]

Drag options to blanks, or click blank then click option'

Aerrorhandler

Babort

Crequest

Drender_template

Attempts:

3 left

💡 Hint

Common Mistakes

Importing 'errorhandler', which cannot be directly imported from Flask.

Importing 'abort' instead of 'render_template'.

The render_template function is used to render custom error pages in Flask.

2fill in blank

medium

Complete the code to create a custom 404 error handler function.

Flask

@app.[1](404)
def not_found(error):
    return 'Page not found', 404

Drag options to blanks, or click blank then click option'

Aerrorhandler

Broute

Cbefore_request

Dafter_request

Attempts:

3 left

💡 Hint

Common Mistakes

Using @app.route instead of @app.errorhandler.

Using request lifecycle decorators like before_request.

The errorhandler decorator registers a function to handle specific HTTP errors like 404.

3fill in blank

hard

Fix the error in the code to return a custom HTML template for 500 errors.

Flask

@app.errorhandler(500)
def server_error(error):
    return [1]('500.html'), 500

Drag options to blanks, or click blank then click option'

Aredirect

Brender_template

Cabort

Drequest

Attempts:

3 left

💡 Hint

Common Mistakes

Using abort instead of render_template.

Trying to redirect instead of rendering a page.

The render_template function renders an HTML file as a response.

4fill in blank

hard

Fill both blanks to log errors and return a JSON response in production.

Flask

import logging

@app.errorhandler(500)
def internal_error(error):
    app.logger.[1]('Server Error: %s', error)
    return {'error': 'Internal Server Error'}, [2]

Drag options to blanks, or click blank then click option'

Aerror

B500

Cwarning

D404

Attempts:

3 left

💡 Hint

Common Mistakes

Logging with 'warning' instead of 'error'.

Returning wrong HTTP status code like 404.

Use app.logger.error to log errors and return HTTP status code 500 for server errors.

5fill in blank

hard

Fill all three blanks to create a custom error handler that logs, renders a template, and returns the correct status code.

Flask

import logging

@app.errorhandler([1])
def handle_error(error):
    app.logger.[2]('Error occurred: %s', error)
    return [3]('error.html'), [1]

Drag options to blanks, or click blank then click option'

A404

Berror

Crender_template

D500

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up error codes 404 and 500.

Using wrong logging level or function to render template.

For a 500 error, log with error level, render the 'error.html' template, and return status 500.

Practice

1. What is the main purpose of using @app.errorhandler in a Flask application?

easy

A. To catch specific errors and provide custom responses

B. To speed up the application startup

C. To automatically restart the server on errors

D. To log user activities

Solution

1. Step 1: Understand the role of @app.errorhandler

   This decorator is used to catch specific HTTP or application errors in Flask.

2. Step 2: Recognize its use for custom responses

   It allows developers to return user-friendly error pages or messages instead of default error traces.

3. Final Answer:

   To catch specific errors and provide custom responses -> Option A

4. Quick Check:

   Error handling = custom responses [OK]

Hint: Errorhandler decorates functions to catch and respond to errors [OK]

Common Mistakes:

• Thinking it restarts the server automatically
• Confusing errorhandler with logging functions
• Assuming it speeds up app startup

2. Which of the following is the correct syntax to handle 404 errors in Flask?

easy

A. @app.error(404)
def not_found(error):
return 'Not found', 404

B. @app.errorhandler(404)
def not_found(error):
return 'Page not found', 404

C. @app.handle_error(404)
def not_found():
return 'Page missing', 404

D. @app.catch_error(404)
def not_found(error):
return '404 error', 404

Solution

1. Step 1: Identify the correct decorator name

   The correct Flask decorator for error handling is @app.errorhandler.

2. Step 2: Confirm function signature and return

   The function should accept an error parameter and return a response with the error code.

3. Final Answer:

   @app.errorhandler(404)\ndef not_found(error):\n return 'Page not found', 404 -> Option B

4. Quick Check:

   Correct decorator and function signature = @app.errorhandler(404) def not_found(error): return 'Page not found', 404 [OK]

Hint: Use @app.errorhandler with error code and error param [OK]

Common Mistakes:

• Using wrong decorator names like @app.handle_error
• Omitting the error parameter in the function
• Returning without the status code

3. Given this Flask code snippet, what will the user see if a 500 error occurs?

@app.errorhandler(500)
def internal_error(error):
    return 'Something went wrong, please try later.', 500

medium

A. The message: 'Something went wrong, please try later.' with status 500

B. A detailed Python traceback error page

C. A blank page with status code 500

D. The default Flask 404 error page

Solution

1. Step 1: Understand the errorhandler function

   The function returns a custom message and status code 500 when a 500 error occurs.

2. Step 2: Identify the user-visible output

   The user will see the returned string message with HTTP status 500, not the default traceback.

3. Final Answer:

   The message: 'Something went wrong, please try later.' with status 500 -> Option A

4. Quick Check:

   Custom error message shown = The message: 'Something went wrong, please try later.' with status 500 [OK]

Hint: Custom errorhandler returns your message, not default trace [OK]

Common Mistakes:

• Expecting Flask's default error page instead of custom message
• Thinking a blank page will appear
• Confusing 500 error with 404 error page

4. What is wrong with this Flask error handler code?

@app.errorhandler(403)
def forbidden():
    return 'Access denied', 403

medium

A. The return statement must include a JSON response

B. The decorator should be @app.handle_error

C. The function must accept an error parameter

D. The status code 403 is invalid

Solution

1. Step 1: Check function signature for errorhandler

   Flask error handler functions must accept the error argument to receive error details.

2. Step 2: Identify missing error parameter

   The function forbidden lacks the required error parameter.

3. Final Answer:

   The function must accept an error parameter -> Option C

4. Quick Check:

   Error handler function needs error param = The function must accept an error parameter [OK]

Hint: Error handler functions always take an error argument [OK]

Common Mistakes:

• Omitting the error parameter in handler functions
• Using wrong decorator names
• Assuming JSON response is mandatory

5. You want to show a friendly error page for all unhandled exceptions in production without exposing debug info. Which Flask setup is best?

hard

A. Use @app.route('/error') to manually show errors

B. Set app.debug = True to see detailed errors

C. Remove all error handlers to let Flask show default error pages

D. Use @app.errorhandler(Exception) to catch all errors and return a simple message

Solution

1. Step 1: Understand catching all exceptions

   Using @app.errorhandler(Exception) catches all unhandled errors globally.

2. Step 2: Provide user-friendly message without debug info

   Returning a simple message hides technical details, improving user experience and security.

3. Final Answer:

   Use @app.errorhandler(Exception) to catch all errors and return a simple message -> Option D

4. Quick Check:

   Global error handler with simple message = Use @app.errorhandler(Exception) to catch all errors and return a simple message [OK]

Hint: Catch Exception globally to hide debug info in production [OK]

Common Mistakes:

• Enabling debug mode in production
• Relying on default Flask error pages
• Using routes instead of error handlers for errors