Profiling Flask applications - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this Flask profiling snippet?

Consider this Flask app snippet using the built-in Werkzeug profiler middleware. What will be the visible effect when accessing the '/' route in a browser?

Flask

from flask import Flask
from werkzeug.middleware.profiler import ProfilerMiddleware

app = Flask(__name__)
app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[30])

@app.route('/')
def index():
    return 'Hello, profiling!'

if __name__ == '__main__':
    app.run(debug=True)

A The app crashes with ImportError because ProfilerMiddleware is not found.

B The browser shows a JSON with profiling data instead of 'Hello, profiling!'.

C The browser shows 'Hello, profiling!' and the console prints detailed profiling stats for the request.

D The browser shows 'Hello, profiling!' but no profiling data is printed anywhere.

💡 Hint

ProfilerMiddleware wraps the app and prints profiling info to the console, not the browser.

ProfilerMiddleware adds profiling output to the server console logs, while the browser still receives the normal response.

📝 Syntax

intermediate

Which option correctly enables Flask profiling with cProfile?

You want to profile your Flask app using Python's cProfile module. Which code snippet correctly runs the app with profiling enabled?

A

from flask import Flask
import cProfile
app = Flask(__name__)

if __name__ == '__main__':
    app.run(debug=True)
cProfile.run()

B

from flask import Flask
app = Flask(__name__)

if __name__ == '__main__':
    app.run(debug=True, profiler=True)

C

import cProfile
from flask import Flask
app = Flask(__name__)

if __name__ == '__main__':
    app.run(debug=True)
cProfile.run('app')

D

import cProfile
from flask import Flask
app = Flask(__name__)

if __name__ == '__main__':
    cProfile.run('app.run(debug=True)')

💡 Hint

cProfile.run() takes a string with the code to run.

Option D correctly calls cProfile.run() with the string to run the Flask app. Other options misuse cProfile or Flask parameters.

🔧 Debug

advanced

Why does this Flask profiling setup not show any profiling output?

You added this code to profile your Flask app but see no profiling output in the console. What is the likely cause?

Flask

from flask import Flask
from werkzeug.middleware.profiler import ProfilerMiddleware

app = Flask(__name__)

@app.route('/')
def index():
    return 'Hello!'

if __name__ == '__main__':
    app.wsgi_app = ProfilerMiddleware(app.wsgi_app)
    app.run()

A ProfilerMiddleware is added after app.run(), so it never wraps the running app.

B ProfilerMiddleware requires debug=True to print output.

C The route '/' must be decorated with @app.profiler to enable profiling.

D ProfilerMiddleware only works with Flask versions below 1.0.

💡 Hint

Check the order of statements in the main block.

app.run() starts the server and blocks, so code after it is never executed. ProfilerMiddleware must wrap the app before running.

❓ state_output

advanced

What is the effect of adding restrictions=[10] to ProfilerMiddleware?

Given this Flask app snippet, what will be the effect of the restrictions parameter?

Flask

from flask import Flask
from werkzeug.middleware.profiler import ProfilerMiddleware

app = Flask(__name__)
app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[10])

@app.route('/')
def index():
    return 'Restricted profiling'

if __name__ == '__main__':
    app.run()

A Only the top 10 functions by cumulative time will be shown in the profiling output.

B Profiling will only run for 10 seconds after the app starts.

C The app will limit requests to 10 per minute for profiling.

D Profiling output will be saved to a file named 'restrictions_10.prof'.

💡 Hint

restrictions controls how many lines of profiling stats are printed.

The restrictions parameter limits the number of lines shown in the profiling report to the top N functions.

🧠 Conceptual

expert

Which profiling approach best isolates Flask route performance without external noise?

You want to profile only the execution time of a specific Flask route handler function, excluding middleware and server overhead. Which approach is best?

A Use cProfile to run the entire Flask app and filter the output manually for the route function.

B Wrap the route function with a custom decorator that uses time.perf_counter() to measure execution time.

C Use ProfilerMiddleware on the whole app and analyze the full request profile.

D Run Flask with debug=True and rely on Flask's built-in profiler output.

💡 Hint

Think about isolating only the route function's execution time.

A custom decorator measuring time inside the route function isolates its performance without external overhead.