Logging configuration in Flask - Step-by-Step Execution

Concept Flow - Logging configuration

Start Flask App

↓

Setup Logging Config

↓

Create Logger Object

↓

Set Logger Level

↓

Add Handlers (Console/File)

↓

Log Messages

↓

Messages Output to Handlers

↓

App Runs with Logging Enabled

This flow shows how a Flask app sets up logging: configure, create logger, set level, add handlers, then log messages output.

Execution Sample

Flask

import logging
from flask import Flask
app = Flask(__name__)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
logger.info('App started')

This code sets up basic logging in Flask and logs an info message when the app starts.

Execution Table

Step	Action	Logger Level	Handlers Attached	Message Logged	Output
1	Import logging and Flask	NOT SET	None	None	No output
2	Create Flask app instance	NOT SET	None	None	No output
3	Call logging.basicConfig(level=logging.INFO)	INFO	Default StreamHandler (console)	None	No output
4	Get logger with getLogger(__name__)	INFO	Default StreamHandler (console)	None	No output
5	Call logger.info('App started')	INFO	Default StreamHandler (console)	'App started'	Printed on console: 'App started'
6	App runs with logging enabled	INFO	Default StreamHandler (console)	Any further logs	Logs appear on console

💡 Logging configured at INFO level; messages below INFO are ignored; app runs with logging active

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
logger.level	NOT SET	INFO	INFO	INFO	INFO
logger.handlers	None	StreamHandler(console)	StreamHandler(console)	StreamHandler(console)	StreamHandler(console)
message	None	None	None	'App started'	Any logged messages

Key Moments - 3 Insights

Why do we not see any output before calling logger.info()?

Because logging only outputs messages when a log method like info() is called, as shown in execution_table step 5.

What happens if we set the logging level to WARNING instead of INFO?

Messages with level INFO would be ignored and not output, as logging only shows messages at or above the set level (see exit_note).

Why do we use getLogger(__name__) instead of root logger?

Using getLogger(__name__) creates a logger specific to the module, allowing better control and filtering, as seen in variable_tracker logger handlers.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what is the logger level when 'App started' is logged?

A DEBUG

B WARNING

C INFO

D ERROR

💡 Hint

Check the 'Logger Level' column at step 5 in the execution_table.

At which step are handlers attached to the logger?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Handlers Attached' column in execution_table to see when handlers appear.

If we change logging.basicConfig(level=logging.WARNING), what happens to the message logged at step 5?

A It will not print because INFO < WARNING

B It will cause an error

C It will still print on console

D It will print twice

💡 Hint

Refer to the exit_note about logging levels filtering messages below the set level.

Concept Snapshot

Logging configuration in Flask:
- Import logging and call logging.basicConfig(level=LEVEL)
- Create logger with getLogger(__name__)
- Set level controls which messages show
- Add handlers to output logs (console/file)
- Use logger.info/debug/error to log messages
- Messages below level are ignored

Full Transcript

This visual execution shows how to configure logging in a Flask app. First, the logging module and Flask are imported. Then, the Flask app instance is created. Next, logging.basicConfig is called to set the logging level to INFO and attach a default console handler. A logger specific to the module is created with getLogger(__name__). When logger.info is called with 'App started', the message is output to the console because the level is INFO. Variables like logger.level and handlers are tracked to show their state changes. Key moments clarify why messages appear only after logging calls and how levels filter output. The quiz tests understanding of logger levels, handler attachment, and message filtering. The snapshot summarizes the steps to configure and use logging in Flask.

Practice

1. What is the main purpose of configuring logging in a Flask application?

easy

A. To speed up the app's response time

B. To record app events and errors for debugging and monitoring

C. To automatically fix bugs in the code

D. To change the app's user interface colors

Solution

1. Step 1: Understand logging purpose

   Logging helps track what happens inside the app, especially errors and events.

2. Step 2: Match purpose to options

   Only To record app events and errors for debugging and monitoring describes recording events and errors for debugging and monitoring.

3. Final Answer:

   To record app events and errors for debugging and monitoring -> Option B

4. Quick Check:

   Logging = record events/errors [OK]

Hint: Logging records events and errors to help debugging [OK]

Common Mistakes:

• Thinking logging speeds up the app
• Believing logging fixes bugs automatically
• Confusing logging with UI changes

2. Which of the following is the correct way to set the logging level to DEBUG using logging.basicConfig in Flask?

easy

A. logging.basicConfig(level='DEBUG')

B. logging.basicConfig(DEBUG)

C. logging.basicConfig(loglevel=logging.DEBUG)

D. logging.basicConfig(level=logging.DEBUG)

Solution

1. Step 1: Recall logging.basicConfig syntax

   The correct syntax requires the keyword argument 'level' with a logging constant like logging.DEBUG.

2. Step 2: Check each option

   logging.basicConfig(level=logging.DEBUG) uses level=logging.DEBUG correctly. logging.basicConfig(DEBUG) misses 'level='. logging.basicConfig(level='DEBUG') uses a string instead of logging.DEBUG constant. logging.basicConfig(loglevel=logging.DEBUG) uses wrong keyword 'loglevel'.

3. Final Answer:

   logging.basicConfig(level=logging.DEBUG) -> Option D

4. Quick Check:

   Use level=logging.DEBUG [OK]

Hint: Use level=logging.DEBUG, not just DEBUG or strings [OK]

Common Mistakes:

• Omitting 'level=' keyword
• Passing level as string instead of logging constant
• Using wrong keyword like 'loglevel'

3. Given this Flask code snippet, what will be the output in the console?

import logging
from flask import Flask
app = Flask(__name__)
logging.basicConfig(level=logging.INFO)

@app.route('/')
def home():
    app.logger.debug('Debug message')
    app.logger.info('Info message')
    return 'Hello!'

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

medium

A. Only 'Debug message' will appear

B. Both 'Debug message' and 'Info message' will appear

C. Only 'Info message' will appear in the console

D. No messages will appear because logging is not configured

Solution

1. Step 1: Check logging level set

   logging.basicConfig(level=logging.INFO) means only INFO and higher levels show, DEBUG is lower and ignored.

2. Step 2: Analyze logged messages

   app.logger.debug('Debug message') is below INFO, so ignored. app.logger.info('Info message') is at INFO level, so it appears.

3. Final Answer:

   Only 'Info message' will appear in the console -> Option C

4. Quick Check:

   Level INFO hides DEBUG [OK]

Hint: INFO level shows info and above, hides debug [OK]

Common Mistakes:

• Assuming debug messages always show
• Confusing logging levels order
• Forgetting to set logging level

4. You wrote this code to configure logging in Flask but no logs appear in the console:

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

logging.basicConfig(format='%(levelname)s:%(message)s')

@app.route('/')
def home():
    app.logger.warning('Warning message')
    return 'Hi'

What is the likely problem?

medium

A. Logging level is not set, defaults to WARNING but basicConfig called too late

B. Format string is incorrect and causes errors

C. app.logger.warning is not a valid method

D. Flask app must be run with debug=True to see logs

Solution

1. Step 1: Understand logging.basicConfig behavior

   basicConfig only works if no logging configured before. Flask may configure logging before this call.

2. Step 2: Identify timing issue

   Calling basicConfig after Flask app creation may not set level or format properly, so logs don't appear.

3. Final Answer:

   Logging level is not set, defaults to WARNING but basicConfig called too late -> Option A

4. Quick Check:

   Call basicConfig before app creation [OK]

Hint: Call basicConfig before creating Flask app [OK]

Common Mistakes:

• Setting format but not level
• Calling basicConfig after app creation
• Thinking debug=True controls logging output

5. You want to log messages to a file named app.log with level WARNING or higher and a custom format showing time, level, and message. Which code snippet correctly configures this in Flask?

hard

A. logging.basicConfig(filename='app.log', level=logging.WARNING, format='%(asctime)s %(levelname)s %(message)s')

B. logging.basicConfig(file='app.log', level='WARNING', format='%(time)s %(level)s %(msg)s')

C. logging.basicConfig(filename='app.log', level='WARNING', format='%(asctime)s %(levelname)s %(message)s')

D. logging.basicConfig(filename='app.log', level=logging.WARNING, format='%(time)s %(level)s %(message)s')

Solution

1. Step 1: Check filename argument

   Correct argument is 'filename', not 'file'. Options B is wrong.

2. Step 2: Check level argument type

   Level must be logging.WARNING constant, not string. Options B and C use string, wrong.

3. Step 3: Check format string placeholders

   Correct placeholders are %(asctime)s, %(levelname)s, %(message)s. Options A and B use wrong placeholders.

4. Final Answer:

   logging.basicConfig(filename='app.log', level=logging.WARNING, format='%(asctime)s %(levelname)s %(message)s') -> Option A

5. Quick Check:

   Use filename, logging.WARNING, correct format placeholders [OK]

Hint: Use filename=, logging.WARNING, and correct format keys [OK]

Common Mistakes:

• Using 'file' instead of 'filename'
• Passing level as string instead of logging constant
• Wrong format placeholders like %(time)s