setSQLLogger is deprecated, how can I disable the logger?

[sdespont]

I used to disable logging in some case using $em->getConnection()->getConfiguration()->setSQLLogger(null);

But now, setSQLLogger is deprecated.
The "Symfony\Bridge\Doctrine\Logger\DbalLogger" class implements "Doctrine\DBAL\Logging\SQLLogger" that is deprecated Use {@see \Doctrine\DBAL\Logging\Middleware} or implement {@see \Doctrine\DBAL\Driver\Middleware} instead.

How can I disable the logger?

[derrabus]

If you use the the middleware, this concern has moved to the logger implementation. In other words, use a PSR-3 logger that you can disable.

[sdespont]

Thank you for your answer. I am not using a middleware. So I need to create one in order to disable it? Do you have some explample to do that?

[derrabus]

If you don't use the middleware, ->setSQLLogger(null) will still work.

[sdespont]

Ok, but the deprecation notice still remains and the method will be removed in the feature isn't it?

[derrabus]

Yes, but it's the whole SQLLogger feature that will go away. As long as you still use it, there is no non-deprecated way to disable logging.

[cyraid]

To remove the Logging Middleware I use:

$conf = $em->getConnection()->getConfiguration();

$mids = $conf->getMiddlewares();
$mids = array_filter($mids, fn($mid) => !($mid instanceof \Doctrine\DBAL\Logging\Middleware));

$conf->setMiddlewares($mids);

$em being of course of EntityManagerInterface. I hope they don't change the location of \Doctrine\DBAL\Logging\Middleware !

Edit: Beware if you're doing this because of Bulk Inserting using persist. I really hope they create a standard way of enforcing bulk inserting rather than having to dance around it like this. Because in the future if they add more Middleware that were to interfere, you'd have another problem using this technique. You could of course setMiddlewares($yourMiddlewares), and make sure you update that whenever you add more middlewares, but this would of course disable other benefits they may have added and takes away from the handy benefit of declaring one with #[AsMiddleware].

[greg0ire]

Here is a PR that might fix this: #11269

[derrabus]

I'm not trying to disable my middleware,

I didn't say that.

I'm trying to remove the logger middleware.

If you don't want the logger middleware at all, why is it configured anyway? You're removing something that should not be there in the first place.

[derrabus]

Also, according to here: https://www.doctrine-project.org/projects/doctrine-orm/en/3.0/reference/batch-processing.html

The documentation is wrong. Thanks for pointing that out, we will change that.

[cyraid]

I use symfony, so this kinda setup should work for batch processing?

dbal:
    regular_connection:
        logging: true
    batch_connection:
        logging: false

You're welcome. I'm glad I found it so it won't lead others (like myself) down that rabbit hole as well.

Thanks for the help guys.

[derrabus]

Yes, that should work.

[derrabus]

To follow up on my previous answer: If you use Monolog in your application, your Monolog and DBAL setup probably looks like this:

use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\DriverManager;
use Doctrine\DBAL\Logging\Middleware as LoggingMiddleware;
use Monolog\Logger;

$logger = new Logger('doctrine');
// Your log handlers are configured here.

$configuration = new Configuration();
$configuration->setMiddlewares([new LoggingMiddleware($logger)]);
// More configuration …

$connection = DriverManager::getConnection(
    [/* Your connection params go here */],
    $configuration,
);

Your mileage may vary because bootstrapping Monolog and DBAL might be abstracted away from you by your framework. For instance, if you use Symfony with DoctrineBundle and MonologBundle, you will likely have a logger registered as service monolog.logger.doctrine that will be wired into your connection.

If you never want to log anything, just don't wire the middleware. Done. Strongly recommended for production. In Symfony, you achieve this by setting logging: false for that connection.

Now, if you just want to disable logging temporarily, you can use a switch like this:

use Monolog\Handler\NullHandler;
use Monolog\Logger;

final readonly class LogSwitch
{
    public function __construct(
        private Logger $logger,
    ) {
    }

    /**
     * @param  callable(): TReturn $callable
     * @return TReturn
     *
     * @template TReturn of mixed
     */
    public function withLoggingDisabled(callable $callable)
    {
        $this->logger->pushHandler(new NullHandler());

        try {
            return $callable();
        } finally {
            $this->logger->popHandler();
        }
    }
}

As you can see, this switch has no idea what a database connection is. It's completely agnostic to the reasons why we want to disable a logger.

You can pass a closure to the only method it exposes and it will execute it while making sure that the given logger is not doing anything while the closure is executed.

// Make sure, $logger is the same logger that we passed to the logging middleware!
$logSwitch = new LogSwitch($logger);

// This query will be logged
$connection->executeQuery('SELECT 1');

$logSwitch->withLoggingDisabled(static function () use ($connection) {
    // This query won't appear in the logs!
    $connection->executeQuery('SELECT 2;');
});

// This query will be logged
$connection->executeQuery('SELECT 1');

---

tl;dr: Disable the actual logger, not the middleware.

[cyraid]

Oh, Symfony automatically includes the logger, which is why I was trying to get rid of it. But you've given me some nice ideas, and whoever comes to see this in the future. Nicely done, thank you for taking the time to help out. :)