如何在带有 mongoengine 的 Flask 项目中使用 pymongo.monitoring

Question

I am trying to add some monitoring to a simple REST web service with flask and mongoengine and have come across what I think is a lack of understanding on my part of how imports and mongoengine is working in flask applications. I'm following pymongo's documentation on monitoring: https://pymongo.readthedocs.io/en/3.7.2/api/pymongo/monitoring.html

I defined the following CommandListener in a separate file:

import logging
from pymongo import monitoring

log = logging.getLogger('my_logger')


class CommandLogger(monitoring.CommandListener):
    def started(self, event):
        log.debug("Command {0.command_name} with request id "
                   "{0.request_id} started on server "
                   "{0.connection_id}".format(event))

monitoring.register(CommandLogger())

I made an application_builder.py file to create my flask App, code looks something like this:

from flask_restful import Api
from flask import Flask

from command_logger import CommandLogger # <----
from db import initialize_db
from routes import initialize_routes

def create_app():
    app = Flask(__name__)
    api = Api(app)
    initialize_db(app)
    initialize_routes(api)
    return app

The monitoring only seems to works if I import: CommandLogger in application_builder.py. I'd like to understand what is going on here, how does the import affect the monitoring registration?

Also I'd like to extract monitoring.register(CommandLogger()) as a function and call it at a latter stage in my code something like def register(): monitoring.register(CommandLogger()) But this doesn't seem to work, "registration' only works when it is in the same file as the CommandLogger class...

Answer 1

From the MongoEngine's doc , it seems important that the listener gets registered before connecting mongoengine

To use pymongo.monitoring with MongoEngine, you need to make sure that you are registering the listeners before establishing the database connection (ie calling connect)

Answer 2

This worked for me. I'm just initializing/registering it the same way as I did other modules to avoid circular imports.

# admin/logger.py

import logging
from pymongo import monitoring

log = logging.getLogger()
log.setLevel(logging.DEBUG)
logging.basicConfig(level=logging.DEBUG)


class CommandLogger(monitoring.CommandListener):

    # def methods... 

class ServerLogger(monitoring.ServerListener):
    
    # def methods

class HeartbeatLogger(monitoring.ServerHeartbeatListener):
   
   # def methods

def initialize_logger():
    monitoring.register(CommandLogger())
    monitoring.register(ServerLogger())
    monitoring.register(HeartbeatLogger())
    monitoring.register(TopologyLogger())

# /app.py

from flask import Flask

from admin.toolbar import initialize_debugtoolbar
from admin.admin import initialize_admin
from admin.views import initialize_views
from admin.logger import initialize_logger
from database.db import initialize_db
from flask_restful import Api
from resources.errors import errors


app = Flask(__name__)

# imports requiring app
from resources.routes import initialize_routes

api = Api(app, errors=errors)

# Logger before db
initialize_logger()

# Database and Routes
initialize_db(app)
initialize_routes(api)

# Admin and Development
initialize_admin(app)
initialize_views()
initialize_debugtoolbar(app)

# /run.py

from app import app

app.run(debug=True)

then in any module...

from admin.logger import log
from db.models import User

# inside some class/view/queryset or however your objects are written...
log.info('Saving an item through MongoEngine...')
User(name='Foo').save()

What I'm trying to figure out now is how to integrate Flask DebuggerToolbar's Logging panel with the monitoring messages from these listeners...