Refactor Cron to use logger_factory instance

[MAILPOET-2444]

lib/Cron/Workers/Scheduler.php

@@ -15,6 +15,7 @@ use MailPoet\Newsletter\Scheduler\Scheduler as NewsletterScheduler;
 use MailPoet\Newsletter\Scheduler\WelcomeScheduler;
 use MailPoet\Segments\SubscribersFinder;
 use MailPoet\Tasks\Sending as SendingTask;
+use MailPoetVendor\Monolog\Logger;
 
 class Scheduler {
   const TASK_BATCH_SIZE = 5;
@@ -24,11 +25,15 @@ class Scheduler {
   /** @var SubscribersFinder */
   private $subscribers_finder;
 
-  function __construct(SubscribersFinder $subscribers_finder, $timer = false) {
+  /** @var LoggerFactory */
+  private $logger_factory;
+
+  function __construct(SubscribersFinder $subscribers_finder, LoggerFactory $logger_factory, $timer = false) {
     $this->timer = ($timer) ? $timer : microtime(true);
     // abort if execution limit is reached
     CronHelper::enforceExecutionLimit($this->timer);
     $this->subscribers_finder = $subscribers_finder;
+    $this->logger_factory = $logger_factory;
   }
 
   function process() {
@@ -78,14 +83,14 @@ class Scheduler {
   }
 
   function processPostNotificationNewsletter($newsletter, $queue) {
-    LoggerFactory::getLogger('post-notifications')->addInfo(
+    $this->logger_factory->getLogger('post-notifications')->addInfo(
       'process post notification in scheduler',
       ['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
     );
     // ensure that segments exist
     $segments = $newsletter->segments()->findMany();
     if (empty($segments)) {
-      LoggerFactory::getLogger('post-notifications')->addInfo(
+      $this->logger_factory->getLogger('post-notifications')->addInfo(
         'post notification no segments',
         ['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
       );
@@ -97,7 +102,7 @@ class Scheduler {
     $subscribers_count = $this->subscribers_finder->addSubscribersToTaskFromSegments($queue->task(), $segments);
 
     if (empty($subscribers_count)) {
-      LoggerFactory::getLogger('post-notifications')->addInfo(
+      $this->logger_factory->getLogger('post-notifications')->addInfo(
         'post notification no subscribers',
         ['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
       );
@@ -114,7 +119,7 @@ class Scheduler {
     $queue->save();
     // update notification status
     $notification_history->setStatus(Newsletter::STATUS_SENDING);
-    LoggerFactory::getLogger('post-notifications')->addInfo(
+    $this->logger_factory->getLogger('post-notifications')->addInfo(
       'post notification set status to sending',
       ['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
     );

lib/Cron/Workers/SendingQueue/SendingQueue.php

@@ -38,7 +38,17 @@ class SendingQueue {
   /** @var MetaInfo */
   private $mailerMetaInfo;
 
-  function __construct(SendingErrorHandler $error_handler, StatsNotificationsScheduler $stats_notifications_scheduler, $timer = false, $mailer_task = false, $newsletter_task = false) {
+  /** @var LoggerFactory */
+  private $logger_factory;
+
+  function __construct(
+    SendingErrorHandler $error_handler,
+    StatsNotificationsScheduler $stats_notifications_scheduler,
+    LoggerFactory $logger_factory,
+    $timer = false,
+    $mailer_task = false,
+    $newsletter_task = false
+  ) {
     $this->error_handler = $error_handler;
     $this->stats_notifications_scheduler = $stats_notifications_scheduler;
     $this->mailer_task = ($mailer_task) ? $mailer_task : new MailerTask();
@@ -47,6 +57,7 @@ class SendingQueue {
     $this->mailerMetaInfo = new MetaInfo;
     $wp = new WPFunctions;
     $this->batch_size = $wp->applyFilters('mailpoet_cron_worker_sending_queue_batch_size', self::BATCH_SIZE);
+    $this->logger_factory = $logger_factory;
   }
 
   function process() {
@@ -55,7 +66,7 @@ class SendingQueue {
       if (!$queue instanceof SendingTask) continue;
       ScheduledTaskModel::touchAllByIds([$queue->task_id]);
 
-      LoggerFactory::getLogger('newsletters')->addInfo(
+      $this->logger_factory->getLogger('newsletters')->addInfo(
         'sending queue processing',
         ['task_id' => $queue->task_id]
       );
@@ -66,7 +77,7 @@ class SendingQueue {
       // pre-process newsletter (render, replace shortcodes/links, etc.)
       $newsletter = $this->newsletter_task->preProcessNewsletter($newsletter, $queue);
       if (!$newsletter) {
-        LoggerFactory::getLogger('newsletters')->addInfo(
+        $this->logger_factory->getLogger('newsletters')->addInfo(
           'delete task in sending queue',
           ['task_id' => $queue->task_id]
         );
@@ -87,7 +98,7 @@ class SendingQueue {
       // get subscribers
       $subscriber_batches = new BatchIterator($queue->task_id, $this->batch_size);
       foreach ($subscriber_batches as $subscribers_to_process_ids) {
-        LoggerFactory::getLogger('newsletters')->addInfo(
+        $this->logger_factory->getLogger('newsletters')->addInfo(
           'subscriber batch processing',
           ['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id, 'subscriber_batch_count' => count($subscribers_to_process_ids)]
         );
@@ -118,7 +129,7 @@ class SendingQueue {
             continue;
           }
         }
-        LoggerFactory::getLogger('newsletters')->addInfo(
+        $this->logger_factory->getLogger('newsletters')->addInfo(
           'before queue chunk processing',
           ['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id, 'found_subscribers_count' => count($found_subscribers)]
         );
@@ -127,12 +138,12 @@ class SendingQueue {
           $_newsletter,
           $found_subscribers
         );
-        LoggerFactory::getLogger('newsletters')->addInfo(
+        $this->logger_factory->getLogger('newsletters')->addInfo(
           'after queue chunk processing',
           ['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
         );
         if ($queue->status === ScheduledTaskModel::STATUS_COMPLETED) {
-          LoggerFactory::getLogger('newsletters')->addInfo(
+          $this->logger_factory->getLogger('newsletters')->addInfo(
             'completed newsletter sending',
             ['newsletter_id' => $newsletter->id, 'task_id' => $queue->task_id]
           );

lib/Cron/Workers/SendingQueue/Tasks/Newsletter.php

@@ -26,6 +26,9 @@ class Newsletter {
   /** @var PostsTask */
   private $posts_task;
 
+  /** @var LoggerFactory */
+  private $logger_factory;
+
   function __construct(WPFunctions $wp = null, PostsTask $posts_task = null) {
     $settings = new SettingsController();
     $this->tracking_enabled = (boolean)$settings->get('tracking.enabled');
@@ -37,6 +40,7 @@ class Newsletter {
       $posts_task = new PostsTask;
     }
     $this->posts_task = $posts_task;
+    $this->logger_factory = LoggerFactory::getInstance();
   }
 
   function getNewsletterFromQueue($queue) {
@@ -74,7 +78,7 @@ class Newsletter {
         $this->stopNewsletterPreProcessing(sprintf('QUEUE-%d-RENDER', $sending_task->id)) :
         $newsletter;
     }
-    LoggerFactory::getLogger('newsletters')->addInfo(
+    $this->logger_factory->getLogger('newsletters')->addInfo(
       'pre-processing newsletter',
       ['newsletter_id' => $newsletter->id, 'task_id' => $sending_task->task_id]
     );
@@ -105,7 +109,7 @@ class Newsletter {
       $this->posts_task->getAlcPostsCount($rendered_newsletter, $newsletter) === 0
     ) {
       // delete notification history record since it will never be sent
-      LoggerFactory::getLogger('post-notifications')->addInfo(
+      $this->logger_factory->getLogger('post-notifications')->addInfo(
         'no posts in post notification, deleting it',
         ['newsletter_id' => $newsletter->id, 'task_id' => $sending_task->task_id]
       );

lib/Cron/Workers/SendingQueue/Tasks/Posts.php

@@ -7,11 +7,18 @@ use MailPoet\Models\Newsletter as NewsletterModel;
 use MailPoet\Models\NewsletterPost;
 
 class Posts {
+  /** @var LoggerFactory */
+  private $logger_factory;
+
+  public function __construct() {
+    $this->logger_factory = LoggerFactory::getInstance();
+  }
+
   function extractAndSave($rendered_newsletter, $newsletter) {
     if ($newsletter->type !== NewsletterModel::TYPE_NOTIFICATION_HISTORY) {
       return false;
     }
-    LoggerFactory::getLogger('post-notifications')->addInfo(
+    $this->logger_factory->getLogger('post-notifications')->addInfo(
       'extract and save posts - before',
       ['newsletter_id' => $newsletter->id]
     );
@@ -30,7 +37,7 @@ class Posts {
       $newsletter_post->post_id = $post_id;
       $newsletter_post->save();
     }
-    LoggerFactory::getLogger('post-notifications')->addInfo(
+    $this->logger_factory->getLogger('post-notifications')->addInfo(
       'extract and save posts - after',
       ['newsletter_id' => $newsletter->id, 'matched_posts_ids' => $matched_posts_ids]
     );

lib/Cron/Workers/WorkersFactory.php

@@ -14,6 +14,7 @@ use MailPoet\Cron\Workers\StatsNotifications\AutomatedEmails as StatsNotificatio
 use MailPoet\Cron\Workers\StatsNotifications\Scheduler as StatsNotificationScheduler;
 use MailPoet\Cron\Workers\StatsNotifications\Worker as StatsNotificationsWorker;
 use MailPoet\Cron\Workers\WooCommerceSync as WooCommerceSyncWorker;
+use MailPoet\Logging\LoggerFactory;
 use MailPoet\Mailer\Mailer;
 use MailPoet\Mailer\MetaInfo;
 use MailPoet\Segments\SubscribersFinder;
@@ -65,6 +66,9 @@ class WorkersFactory {
   /** @var MetaInfo */
   private $mailerMetaInfo;
 
+  /** @var LoggerFactory */
+  private $logger_factory;
+
   public function __construct(
     SendingErrorHandler $sending_error_handler,
     StatsNotificationScheduler $statsNotificationsScheduler,
@@ -77,7 +81,8 @@ class WorkersFactory {
     WooCommercePurchases $woocommerce_purchases,
     AuthorizedEmailsController $authorized_emails_controller,
     SubscribersFinder $subscribers_finder,
-    MetaInfo $mailerMetaInfo
+    MetaInfo $mailerMetaInfo,
+    LoggerFactory $logger_factory
   ) {
     $this->sending_error_handler = $sending_error_handler;
     $this->statsNotificationsScheduler = $statsNotificationsScheduler;
@@ -91,16 +96,17 @@ class WorkersFactory {
     $this->authorized_emails_controller = $authorized_emails_controller;
     $this->subscribers_finder = $subscribers_finder;
     $this->mailerMetaInfo = $mailerMetaInfo;
+    $this->logger_factory = $logger_factory;
   }
 
   /** @return SchedulerWorker */
   function createScheduleWorker($timer) {
-    return new SchedulerWorker($this->subscribers_finder, $timer);
+    return new SchedulerWorker($this->subscribers_finder, $this->logger_factory, $timer);
   }
 
   /** @return SendingQueueWorker */
   function createQueueWorker($timer) {
-    return new SendingQueueWorker($this->sending_error_handler, $this->statsNotificationsScheduler, $timer);
+    return new SendingQueueWorker($this->sending_error_handler, $this->statsNotificationsScheduler, $this->logger_factory, $timer);
   }
 
   /** @return StatsNotificationsWorker */

tests/integration/Cron/Workers/SchedulerTest.php

@@ -7,6 +7,7 @@ use Codeception\Stub;
 use Codeception\Stub\Expected;
 use MailPoet\Cron\CronHelper;
 use MailPoet\Cron\Workers\Scheduler;
+use MailPoet\Logging\LoggerFactory;
 use MailPoet\Models\Newsletter;
 use MailPoet\Models\NewsletterOption;
 use MailPoet\Models\NewsletterOptionField;
@@ -23,17 +24,25 @@ use MailPoet\Segments\SubscribersFinder;
 use MailPoet\Tasks\Sending as SendingTask;
 
 class SchedulerTest extends \MailPoetTest {
+  /** @var LoggerFactory */
+  private $logger_factory;
+
+  function _before() {
+    parent::_before();
+    $this->logger_factory = LoggerFactory::getInstance();
+  }
+
   function testItConstructs() {
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     expect($scheduler->timer)->greaterOrEquals(5);
     $timer = microtime(true) - 2;
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $timer);
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, $timer);
     expect($scheduler->timer)->equals($timer);
   }
 
   function testItThrowsExceptionWhenExecutionLimitIsReached() {
     try {
-      $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), microtime(true) - CronHelper::getDaemonExecutionLimit());
+      $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory, microtime(true) - CronHelper::getDaemonExecutionLimit());
       self::fail('Maximum execution time limit exception was not thrown.');
     } catch (\Exception $e) {
       expect($e->getMessage())->equals('Maximum execution time has been reached.');
@@ -62,7 +71,7 @@ class SchedulerTest extends \MailPoetTest {
     expect($notification_history)->isEmpty();
 
     // create notification history and ensure that it exists
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     $scheduler->createNotificationHistory($newsletter->id);
     $notification_history = Newsletter::where('type', Newsletter::TYPE_NOTIFICATION_HISTORY)
       ->where('parent_id', $newsletter->id)
@@ -78,7 +87,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // queue and associated newsletter should be deleted when interval type is set to "immediately"
     expect(SendingQueue::findMany())->notEmpty();
@@ -94,7 +103,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // queue's next run date should change when interval type is set to anything
     // other than "immediately"
@@ -124,7 +133,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // return false and delete queue when subscriber is not a WP user
     $result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@@ -147,7 +156,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // return false and delete queue when subscriber role is different from the one
     // specified for the welcome email
@@ -169,7 +178,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // return true when user exists and WP role matches the one specified for the welcome email
     $result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@@ -190,7 +199,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_WELCOME)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // true when user exists and has any role
     $result = $scheduler->verifyWPSubscriber($subscriber->id, $newsletter, $queue);
@@ -204,7 +213,7 @@ class SchedulerTest extends \MailPoetTest {
     $queue->setSubscribers([]);
 
     // delete queue when the list of subscribers to process is blank
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     $result = $scheduler->processWelcomeNewsletter($newsletter, $queue);
     expect($result)->false();
     expect(SendingQueue::findMany())->count(0);
@@ -274,7 +283,7 @@ class SchedulerTest extends \MailPoetTest {
   }
 
   function testItFailsMailpoetSubscriberVerificationWhenSubscriberDoesNotExist() {
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     $newsletter = $this->_createNewsletter();
     $queue = $this->_createQueue($newsletter->id);
 
@@ -294,7 +303,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // return false
     $result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@@ -319,7 +328,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // return false
     $result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@@ -348,7 +357,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // return false
     $result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@@ -371,7 +380,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
 
     // return true after successful verification
     $result = $scheduler->verifyMailpoetSubscriber($subscriber->id, $newsletter, $queue);
@@ -393,7 +402,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
     $queue = $this->_createQueue($newsletter->id);
-    $scheduler = new Scheduler(new SubscribersFinder());
+    $scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory);
 
     // return true
     expect($scheduler->processScheduledStandardNewsletter($newsletter, $queue))->true();
@@ -417,6 +426,7 @@ class SchedulerTest extends \MailPoetTest {
       'deleteQueueOrUpdateNextRunDate' => Expected::exactly(1, function() {
         return false;
       }),
+      'logger_factory' => $this->logger_factory,
     ], $this);
     expect($scheduler->processPostNotificationNewsletter($newsletter, $queue))->false();
   }
@@ -428,7 +438,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter_segment = $this->_createNewsletterSegment($newsletter->id, $segment->id);
 
     // delete or reschedule queue when there are no subscribers in segments
-    $scheduler = $this->construct(Scheduler::class, [new SubscribersFinder()], [
+    $scheduler = $this->construct(Scheduler::class, [new SubscribersFinder(), $this->logger_factory], [
       'deleteQueueOrUpdateNextRunDate' => Expected::exactly(1, function() {
         return false;
       }),
@@ -451,7 +461,7 @@ class SchedulerTest extends \MailPoetTest {
     );
     $newsletter = Newsletter::filter('filterWithOptions', Newsletter::TYPE_NOTIFICATION)
       ->findOne($newsletter->id);
-    $scheduler = new Scheduler(new SubscribersFinder());
+    $scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory);
 
     // return true
     expect($scheduler->processPostNotificationNewsletter($newsletter, $queue))->true();
@@ -472,7 +482,7 @@ class SchedulerTest extends \MailPoetTest {
   }
 
   function testItFailsToProcessWhenScheduledQueuesNotFound() {
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     expect($scheduler->process())->false();
   }
 
@@ -480,7 +490,7 @@ class SchedulerTest extends \MailPoetTest {
     $queue = $this->_createQueue(1);
     $queue->scheduled_at = Carbon::createFromTimestamp(current_time('timestamp'));
     $queue->save();
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     $scheduler->process();
     expect(SendingQueue::findMany())->count(0);
   }
@@ -492,7 +502,7 @@ class SchedulerTest extends \MailPoetTest {
     $queue = $this->_createQueue($newsletter->id);
     $queue->scheduled_at = Carbon::createFromTimestamp(current_time('timestamp'));
     $queue->save();
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     $scheduler->process();
     expect(SendingQueue::findMany())->count(0);
   }
@@ -587,7 +597,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = $this->_createNewsletter(Newsletter::TYPE_STANDARD, Newsletter::STATUS_DRAFT);
     $queue = $this->_createQueue($newsletter->id);
     $finder = $this->makeEmpty(SubscribersFinder::class);
-    $scheduler = new Scheduler($finder);
+    $scheduler = new Scheduler($finder, $this->logger_factory);
 
     $scheduler->processScheduledStandardNewsletter($newsletter, $queue);
     $refetched_task = ScheduledTask::where('id', $task->id)->findOne();
@@ -603,7 +613,7 @@ class SchedulerTest extends \MailPoetTest {
     $newsletter = $this->_createNewsletter(Newsletter::TYPE_STANDARD, Newsletter::STATUS_DRAFT);
     $queue = $this->_createQueue($newsletter->id);
     $finder = $this->makeEmpty(SubscribersFinder::class);
-    $scheduler = new Scheduler($finder);
+    $scheduler = new Scheduler($finder, $this->logger_factory);
 
     $scheduler->processScheduledStandardNewsletter($newsletter, $queue);
     $refetched_task = ScheduledTask::where('id', $task->id)->findOne();
@@ -641,7 +651,7 @@ class SchedulerTest extends \MailPoetTest {
     expect($task->getSubscribers())->equals([$subscriber->id]);
 
     // task should have its status set to null (i.e., sending)
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     $scheduler->process();
     $task = SendingTask::getByNewsletterId($newsletter->id);
     expect($task->status)->null();
@@ -665,7 +675,7 @@ class SchedulerTest extends \MailPoetTest {
     expect($task->getSubscribers())->equals([$subscriber->id]);
 
     // task should be deleted
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     $scheduler->process();
     $task = SendingTask::getByNewsletterId($newsletter->id);
     expect($task)->false();
@@ -693,7 +703,7 @@ class SchedulerTest extends \MailPoetTest {
     expect($task->newsletter_id)->equals($newsletter->id);
 
     // task should have its status set to null (i.e., sending)
-    $scheduler = new Scheduler(new SubscribersFinder());
+    $scheduler = new Scheduler(new SubscribersFinder(), $this->logger_factory);
     $scheduler->process();
     $task = SendingTask::getByNewsletterId($newsletter->id);
     expect($task->status)->null();
@@ -710,7 +720,7 @@ class SchedulerTest extends \MailPoetTest {
     $queue->scheduled_at = Carbon::createFromTimestamp(current_time('timestamp'));
     $queue->updated_at = $originalUpdated;
     $queue->save();
-    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class));
+    $scheduler = new Scheduler($this->makeEmpty(SubscribersFinder::class), $this->logger_factory);
     $scheduler->timer = microtime(true);
     $scheduler->process();
     $newQueue = ScheduledTask::findOne($queue->task_id);

tests/integration/Cron/Workers/SendingQueue/SendingQueueTest.php

@@ -13,6 +13,7 @@ use MailPoet\Cron\Workers\SendingQueue\Tasks\Mailer as MailerTask;
 use MailPoet\Cron\Workers\SendingQueue\Tasks\Newsletter as NewsletterTask;
 use MailPoet\Cron\Workers\StatsNotifications\Scheduler as StatsNotificationsScheduler;
 use MailPoet\Features\FeaturesController;
+use MailPoet\Logging\LoggerFactory;
 use MailPoet\Mailer\MailerLog;
 use MailPoet\Models\Newsletter;
 use MailPoet\Models\NewsletterLink;
@@ -45,6 +46,8 @@ class SendingQueueTest extends \MailPoetTest {
   private $settings;
   /** @var Scheduler */
   private $stats_notifications_worker;
+  /** @var LoggerFactory */
+  private $logger_factory;
 
   function _before() {
     parent::_before();
@@ -93,7 +96,8 @@ class SendingQueueTest extends \MailPoetTest {
     $this->newsletter_link->save();
     $this->sending_error_handler = new SendingErrorHandler();
     $this->stats_notifications_worker = new StatsNotificationsScheduler($this->settings);
-    $this->sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker);
+    $this->logger_factory = LoggerFactory::getInstance();
+    $this->sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory);
   }
 
   private function getDirectUnsubscribeURL() {
@@ -124,20 +128,20 @@ class SendingQueueTest extends \MailPoetTest {
 
     // constructor accepts timer argument
     $timer = microtime(true) - 5;
-    $sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $timer);
+    $sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory, $timer);
     expect($sending_queue_worker->timer)->equals($timer);
   }
 
   function testItEnforcesExecutionLimitsBeforeQueueProcessing() {
     $sending_queue_worker = Stub::make(
-      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker),
+      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory),
       [
         'processQueue' => Expected::never(),
         'enforceSendingAndExecutionLimits' => Expected::exactly(1, function() {
           throw new \Exception();
         }),
       ], $this);
-    $sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker);
+    $sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory);
     try {
       $sending_queue_worker->process();
       self::fail('Execution limits function was not called.');
@@ -148,13 +152,14 @@ class SendingQueueTest extends \MailPoetTest {
 
   function testItEnforcesExecutionLimitsAfterSendingWhenQueueStatusIsNotSetToComplete() {
     $sending_queue_worker = Stub::make(
-      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker),
+      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory),
       [
         'enforceSendingAndExecutionLimits' => Expected::exactly(1),
       ], $this);
     $sending_queue_worker->__construct(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -183,13 +188,14 @@ class SendingQueueTest extends \MailPoetTest {
     $queue = $this->queue;
     $queue->status = SendingQueue::STATUS_COMPLETED;
     $sending_queue_worker = Stub::make(
-      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker),
+      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory),
       [
         'enforceSendingAndExecutionLimits' => Expected::never(),
       ], $this);
     $sending_queue_worker->__construct(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -213,7 +219,7 @@ class SendingQueueTest extends \MailPoetTest {
 
   function testItEnforcesExecutionLimitsAfterQueueProcessing() {
     $sending_queue_worker = Stub::make(
-      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker),
+      new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory),
       [
         'processQueue' => function() {
           // this function returns a queue object
@@ -221,7 +227,7 @@ class SendingQueueTest extends \MailPoetTest {
         },
         'enforceSendingAndExecutionLimits' => Expected::exactly(2),
       ], $this);
-    $sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker);
+    $sending_queue_worker->__construct($this->sending_error_handler, $this->stats_notifications_worker, $this->logger_factory);
     $sending_queue_worker->process();
   }
 
@@ -246,6 +252,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -274,6 +281,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -300,6 +308,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -345,6 +354,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -393,6 +403,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -448,6 +459,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::makeEmpty(new MailerTask(), [], $this)
     );
@@ -464,6 +476,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -514,6 +527,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -676,10 +690,15 @@ class SendingQueueTest extends \MailPoetTest {
       ->method('__get')
       ->with('id')
       ->will($this->returnValue(100));
-    $sending_queue_worker = Stub::make(new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker));
+    $sending_queue_worker = Stub::make(new SendingQueueWorker(
+      $this->sending_error_handler,
+      $this->stats_notifications_worker,
+      $this->logger_factory
+    ));
     $sending_queue_worker->__construct(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -714,6 +733,7 @@ class SendingQueueTest extends \MailPoetTest {
     $sending_queue_worker = new SendingQueueWorker(
       $this->sending_error_handler,
       $this->stats_notifications_worker,
+      $this->logger_factory,
       $timer = false,
       Stub::make(
         new MailerTask(),
@@ -738,7 +758,11 @@ class SendingQueueTest extends \MailPoetTest {
     };
     $wp = new WPFunctions;
     $wp->addFilter('mailpoet_cron_worker_sending_queue_batch_size', $filter);
-    $sending_queue_worker = new SendingQueueWorker($this->sending_error_handler, $this->stats_notifications_worker);
+    $sending_queue_worker = new SendingQueueWorker(
+      $this->sending_error_handler,
+      $this->stats_notifications_worker,
+      $this->logger_factory
+    );
     expect($sending_queue_worker->batch_size)->equals($custom_batch_size_value);
     $wp->removeFilter('mailpoet_cron_worker_sending_queue_batch_size', $filter);
   }

tests/integration/Cron/Workers/SendingQueue/Tasks/NewsletterTest.php

@@ -7,6 +7,7 @@ use Codeception\Util\Fixtures;
 use Helper\WordPressHooks as WPHooksHelper;
 use MailPoet\Cron\Workers\SendingQueue\Tasks\Newsletter as NewsletterTask;
 use MailPoet\Cron\Workers\SendingQueue\Tasks\Posts as PostsTask;
+use MailPoet\Logging\LoggerFactory;
 use MailPoet\Mailer\MailerLog;
 use MailPoet\Models\Newsletter;
 use MailPoet\Models\NewsletterLink;
@@ -36,6 +37,9 @@ class NewsletterTest extends \MailPoetTest {
   /** @var SendingTask */
   private $queue;
 
+  /** @var LoggerFactory */
+  private $logger_factory;
+
   function _before() {
     parent::_before();
     $this->newsletter_task = new NewsletterTask();
@@ -61,6 +65,7 @@ class NewsletterTest extends \MailPoetTest {
     $this->queue = SendingTask::create();
     $this->queue->newsletter_id = $this->newsletter->id;
     $this->queue->save();
+    $this->logger_factory = LoggerFactory::getInstance();
   }
 
   function testItConstructs() {
@@ -208,6 +213,7 @@ class NewsletterTest extends \MailPoetTest {
     $this->newsletter->parent_id = $this->newsletter->id;
     $posts_task = $this->make(PostsTask::class, [
       'getAlcPostsCount' => 1,
+      'logger_factory' => $this->logger_factory,
     ]);
     $newsletter_task = new NewsletterTask(new WPFunctions, $posts_task);
     $result = $newsletter_task->preProcessNewsletter($this->newsletter, $this->queue);