# Logger

1

how to access flask logger in another python file

To access the Flask logger from another Python file, you can use a few different approaches depending on the structure of your application and your specific requirements. Here, I’ll provide guidance on how to set up and access the Flask logger across different modules of your application.

#### Basic Flask App Setup

First, let’s set up a basic Flask application. Assume this is in a file called `app.py`:

```python
from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    app.logger.info('Home page visited')
    return 'Hello, Flask!'

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

In the above code, `app.logger` is used to log a message whenever the home page is accessed.

#### Accessing Flask Logger in Another Module

If you want to access the `app.logger` from another file, let’s say `utils.py`, you should ensure that you import `app` from `app.py` in a way that does not create circular dependencies. Here's how you can structure this:

**utils.py**

```python
from app import app

def do_something():
    app.logger.info('Doing something important')
    # Implement the function's main functionality here
```

**Modified app.py**

To avoid circular imports, you might need to organize your application initialization and routes in a slightly different way:

```python
from flask import Flask

app = Flask(__name__)

import utils  # Import utils after app is defined to avoid circular imports

@app.route('/')
def home():
    app.logger.info('Home page visited')
    utils.do_something()  # Call a function from another module
    return 'Hello, Flask!'

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

#### Use Application Factory Pattern

For larger applications, it's common to use the application factory pattern. This approach can also help manage the logger more effectively across different modules.

**factory.py**

```python
from flask import Flask

def create_app():
    app = Flask(__name__)
    
    with app.app_context():
        # Import parts of our application
        from .routes import main
        app.register_blueprint(main)

        # Setup logger
        app.logger.info('Flask app created')
    
    return app
```

**routes.py**

```python
from flask import Blueprint

main = Blueprint('main', __name__)

@main.route('/')
def home():
    from flask import current_app
    current_app.logger.info('Visited home page')
    return 'Hello from Blueprint!'
```

**utils.py (revised for application factory)**

```python
from flask import current_app

def do_something():
    current_app.logger.info('Doing something important')
```

Using `current_app.logger` accesses the logger of the active Flask application, which can be different depending on the context. This is particularly useful when using an application factory pattern where `app` is not directly importable.

#### Summary

* For simple projects or those just beginning, you can import `app` directly and use `app.logger`.
* For larger, more complex projects, consider using the application factory pattern and `current_app.logger` to ensure your logging is manageable and scalable.

Each approach has its place depending on the complexity and structure of your Flask application.

***

2
