diff --git a/src/Queue/Admin/DataExtension.php b/src/Queue/Admin/DataExtension.php
new file mode 100644
index 00000000..ef16da95
--- /dev/null
+++ b/src/Queue/Admin/DataExtension.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Queue\Admin;
+
+use SilverStripe\Forms\FieldList;
+use SilverStripe\Forms\LiteralField;
+use SilverStripe\Forms\TextareaField;
+use SilverStripe\ORM\DataExtension as BaseDataExtension;
+use Symbiote\QueuedJobs\DataObjects\QueuedJobDescriptor;
+
+/**
+ * Class DataExtension
+ *
+ * @property QueuedJobDescriptor|$this $owner
+ * @package App\Queue\Admin
+ */
+class DataExtension extends BaseDataExtension
+{
+
+    /**
+     * @param FieldList $fields
+     */
+    public function updateCMSFields(FieldList $fields): void
+    {
+        $owner = $this->owner;
+
+        $fields->addFieldsToTab('Root.JobData', [
+            $jobDataPreview = TextareaField::create('SavedJobDataPreview', 'Job Data'),
+        ]);
+
+        if (strlen($owner->getMessagesRaw()) > 0) {
+            $fields->addFieldToTab(
+                'Root.MessagesRaw',
+                $messagesRaw = LiteralField::create('MessagesRaw', $owner->getMessagesRaw())
+            );
+        }
+
+        $jobDataPreview->setReadonly(true);
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getSavedJobDataPreview(): ?string
+    {
+        return $this->owner->SavedJobData;
+    }
+
+    /**
+     * @return string|null
+     */
+    public function getMessagesRaw(): ?string
+    {
+        return $this->owner->SavedJobMessages;
+    }
+
+    /**
+     * @return string
+     */
+    public function getImplementationSummary(): string
+    {
+        $segments = explode('\\', $this->owner->Implementation);
+
+        while (count($segments) > 2) {
+            array_shift($segments);
+        }
+
+        return implode('\\', $segments);
+    }
+}
diff --git a/src/Queue/Admin/Extension.php b/src/Queue/Admin/Extension.php
new file mode 100644
index 00000000..1db3c5d8
--- /dev/null
+++ b/src/Queue/Admin/Extension.php
@@ -0,0 +1,222 @@
+<?php
+
+namespace App\Queue\Admin;
+
+use SilverStripe\Core\Extension as BaseExtension;
+use SilverStripe\Forms\DropdownField;
+use SilverStripe\Forms\Form;
+use SilverStripe\Forms\GridField\GridField;
+use SilverStripe\Forms\GridField\GridFieldConfig;
+use SilverStripe\Forms\GridField\GridFieldDataColumns;
+use SilverStripe\Forms\GridField\GridFieldFilterHeader;
+use SilverStripe\Forms\GridField\GridFieldPaginator;
+use SilverStripe\ORM\DataList;
+use SilverStripe\ORM\FieldType\DBDatetime;
+use Symbiote\QueuedJobs\Controllers\QueuedJobsAdmin;
+use Symbiote\QueuedJobs\DataObjects\QueuedJobDescriptor;
+use Terraformers\RichFilterHeader\Form\GridField\RichFilterHeader;
+
+/**
+ * Class Extension
+ *
+ * @property QueuedJobsAdmin|$this $owner
+ * @package App\Queue\Admin
+ */
+class Extension extends BaseExtension
+{
+
+    private const SCHEDULED_FILTER_FUTURE = 'future';
+    private const SCHEDULED_FILTER_PAST = 'past';
+
+    /**
+     * @param Form $form
+     */
+    public function updateEditForm(Form $form): void
+    {
+        $fields = $form->Fields();
+
+        // there are multiple fields that need to be updated
+        $fieldNames = [
+            'QueuedJobDescriptor',
+            $this->encodeClassName(QueuedJobDescriptor::class),
+        ];
+
+        foreach ($fieldNames as $fieldName) {
+            /** @var GridField $gridField */
+            $gridField = $fields->fieldByName($fieldName);
+
+            if (!$gridField) {
+                continue;
+            }
+
+            $config = $gridField->getConfig();
+
+            // apply custom filters
+            $this->customiseFilters($config);
+        }
+    }
+
+    /**
+     * Customise queued jobs filters UI
+     *
+     * @param GridFieldConfig $config
+     */
+    private function customiseFilters(GridFieldConfig $config): void
+    {
+        /** @var GridFieldDataColumns $gridFieldColumns */
+        $gridFieldColumns = $config->getComponentByType(GridFieldDataColumns::class);
+
+        $gridFieldColumns->setDisplayFields([
+            'getImplementationSummary' => 'Type',
+            'JobTypeString' => 'Queue',
+            'JobStatus' => 'Status',
+            'JobTitle' => 'Description',
+            'Created' => 'Added',
+            'StartAfter' => 'Scheduled',
+            'JobFinished' => 'Finished',
+        ]);
+
+        $config->removeComponentsByType(GridFieldFilterHeader::class);
+
+        $filter = new RichFilterHeader();
+        $filter
+            ->setFilterConfig([
+                'getImplementationSummary' => 'Implementation',
+                'Description' => 'JobTitle',
+                'Status' => [
+                    'title' => 'JobStatus',
+                    'filter' => 'ExactMatchFilter',
+                ],
+                'JobTypeString' => [
+                    'title' => 'JobType',
+                    'filter' => 'ExactMatchFilter',
+                ],
+                'Created' => 'Added',
+                'StartAfter' => 'Scheduled',
+            ])
+            ->setFilterFields([
+                'JobType' => $queueType = DropdownField::create(
+                    '',
+                    '',
+                    $this->getQueueTypes()
+                ),
+                'JobStatus' => $jobStatus = DropdownField::create(
+                    '',
+                    '',
+                    $this->getJobStatuses()
+                ),
+                'Added' => $added = DropdownField::create(
+                    '',
+                    '',
+                    $this->getAddedDates()
+                ),
+                'Scheduled' => $scheduled = DropdownField::create(
+                    '',
+                    '',
+                    [
+                        self::SCHEDULED_FILTER_FUTURE => self::SCHEDULED_FILTER_FUTURE,
+                        self::SCHEDULED_FILTER_PAST => self::SCHEDULED_FILTER_PAST,
+                    ]
+                ),
+            ])
+            ->setFilterMethods([
+                'Added' => static function (DataList $list, $name, $value): DataList {
+                    if ($value) {
+                        $added = DBDatetime::now()->modify($value);
+
+                        return $list->filter(['Created:LessThanOrEqual' => $added->Rfc2822()]);
+                    }
+
+                    return $list;
+                },
+                'Scheduled' => static function (DataList $list, $name, $value): DataList {
+                    if ($value === static::SCHEDULED_FILTER_FUTURE) {
+                        return $list->filter([
+                            'StartAfter:GreaterThan' => DBDatetime::now()->Rfc2822(),
+                        ]);
+                    }
+
+                    if ($value === static::SCHEDULED_FILTER_PAST) {
+                        return $list->filter([
+                            'StartAfter:LessThanOrEqual' => DBDatetime::now()->Rfc2822(),
+                        ]);
+                    }
+
+                    return $list;
+                },
+            ]);
+
+        foreach ([$jobStatus, $queueType, $added, $scheduled] as $dropDownField) {
+            /** @var DropdownField $dropDownField */
+            $dropDownField->setEmptyString('-- select --');
+        }
+
+        $config->addComponent($filter, GridFieldPaginator::class);
+    }
+
+    /**
+     * Queue types options for drop down field
+     *
+     * @return array
+     */
+    private function getQueueTypes(): array
+    {
+        /** @var QueuedJobDescriptor $job */
+        $job = QueuedJobDescriptor::singleton();
+        $map = $job->getJobTypeValues();
+        $values = array_values($map);
+        $keys = [];
+
+        foreach (array_keys($map) as $key) {
+            $keys[] = (int) $key;
+        }
+
+        return array_combine($keys, $values);
+    }
+
+    /**
+     * All possible job statuses (this list is not exposed by the module)
+     * intended to be used in a drop down field
+     *
+     * @return array
+     */
+    private function getJobStatuses(): array
+    {
+        /** @var QueuedJobDescriptor $job */
+        $job = QueuedJobDescriptor::singleton();
+        $statuses = $job->getJobStatusValues();
+
+        sort($statuses, SORT_STRING);
+
+        $statuses = array_combine($statuses, $statuses);
+
+        return $statuses;
+    }
+
+    /**
+     * Encode class name to match the matching CMS field name
+     *
+     * @param string $className
+     * @return string
+     */
+    private function encodeClassName(string $className): string
+    {
+        return str_replace('\\', '-', $className);
+    }
+
+    /**
+     * Date options for added dates drop down field
+     *
+     * @return array
+     */
+    private function getAddedDates(): array
+    {
+        return [
+            '-1 day' => '1 day or older',
+            '-3 day' => '3 days or older',
+            '-7 day' => '7 days or older',
+            '-14 day' => '14 days or older',
+            '-1 month' => '1 month or older',
+        ];
+    }
+}
diff --git a/src/Queue/Cleanup/Task.php b/src/Queue/Cleanup/Task.php
new file mode 100644
index 00000000..0981392f
--- /dev/null
+++ b/src/Queue/Cleanup/Task.php
@@ -0,0 +1,63 @@
+<?php
+
+namespace App\Queue\Cleanup;
+
+use SilverStripe\Control\HTTPRequest;
+use SilverStripe\Dev\BuildTask;
+use SilverStripe\ORM\DB;
+use SilverStripe\ORM\FieldType\DBDatetime;
+use Symbiote\QueuedJobs\DataObjects\QueuedJobDescriptor;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+use Symbiote\QueuedJobs\Services\QueuedJobService;
+
+/**
+ * Class Task
+ *
+ * Delete all expired completed jobs
+ *
+ * @package App\Queue\Cleanup
+ */
+class Task extends BuildTask
+{
+
+    private const EXPIRY_HOURS = 24;
+    private const EXPIRY_LIMIT = 10000;
+
+    /**
+     * @var string
+     */
+    private static $segment = 'queued-jobs-cleanup';
+
+    /**
+     * @var string
+     */
+    protected $description = 'Delete job descriptors that are older than the configured expiry';
+
+    /**
+     * @param HTTPRequest $request
+     */
+    public function run($request): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        if (QueuedJobService::singleton()->isMaintenanceLockActive()) {
+            return;
+        }
+
+        $table = QueuedJobDescriptor::config()->get('table_name');
+
+        // determine expiry
+        $expired = DBDatetime::now()->modify(sprintf('-%s hours', self::EXPIRY_HOURS))->Rfc2822();
+
+        // Format query
+        $query = sprintf(
+            "DELETE FROM `%s` WHERE `JobStatus` = '%s' AND (`JobFinished` <= '%s' OR `JobFinished` IS NULL) LIMIT %d",
+            $table,
+            QueuedJob::STATUS_COMPLETE,
+            $expired,
+            self::EXPIRY_LIMIT
+        );
+
+        DB::query($query);
+
+        echo sprintf('%d job descriptors deleted.', (int) DB::affected_rows());
+    }
+}
diff --git a/src/Queue/Dev/Job.php b/src/Queue/Dev/Job.php
new file mode 100644
index 00000000..b15883f5
--- /dev/null
+++ b/src/Queue/Dev/Job.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Queue\Dev;
+
+use App\Queue;
+use SilverStripe\ORM\FieldType\DBDatetime;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+
+/**
+ * Class Job
+ *
+ * This is a test job which is intended to be used for testing the queue runner
+ * the job runs multiple steps and eventually completes
+ *
+ * @property int $randomID
+ * @package App\Queue\Dev
+ */
+class Job extends Queue\Job
+{
+
+    /**
+     * @var string|null
+     */
+    private $type = QueuedJob::QUEUED;
+
+    public function hydrate(int $type, int $randomID): void
+    {
+        $this->type = $type;
+        $this->randomID = $randomID;
+        $this->items = [1, 2, 3, 4, 5];
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle(): string
+    {
+        return 'Test job';
+    }
+
+    /**
+     * @return int|null
+     */
+    public function getJobType(): int
+    {
+        return (int) $this->type;
+    }
+
+    public function getRunAsMemberID(): ?int
+    {
+        return 0;
+    }
+
+    /**
+     * @param mixed $item
+     */
+    public function processItem($item): void
+    {
+        $this->addMessage(sprintf('Step %d at %s', $item, DBDatetime::now()->Rfc2822()));
+        sleep(1);
+    }
+}
diff --git a/src/Queue/Dev/Task.php b/src/Queue/Dev/Task.php
new file mode 100644
index 00000000..11b234d4
--- /dev/null
+++ b/src/Queue/Dev/Task.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Queue\Dev;
+
+use SilverStripe\Control\HTTPRequest;
+use SilverStripe\Dev\BuildTask;
+use SilverStripe\ORM\FieldType\DBDatetime;
+use SilverStripe\ORM\ValidationException;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+use Symbiote\QueuedJobs\Services\QueuedJobService;
+
+/**
+ * Class Task
+ *
+ * This dev task is intended to be used for testing the queue runner
+ * use it to create test jobs in your queue so you can run them and observe the whole process
+ *
+ * @package App\Queue\Dev
+ */
+class Task extends BuildTask
+{
+
+    /**
+     * @var string
+     */
+    private static $segment = 'generate-test-jobs-task';
+
+    /**
+     * @return string
+     */
+    public function getDescription(): string
+    {
+        return 'Create test jobs for queue testing purposes.';
+    }
+
+    /**
+     * @param HTTPRequest $request
+     * @throws ValidationException
+     */
+    public function run($request): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        echo '<p>Pass GET param ?total=x to create x jobs.</p>';
+        echo '<p>Pass GET param ?type=(2|3) to create jobs in medium|large queues respectively'
+            . ' (defaults to large).</p>';
+
+        $total = $request->getVar('total') ?: 0;
+        $type = $request->getVar('type') ?: QueuedJob::LARGE;
+        $service = QueuedJobService::singleton();
+
+        for ($i = 1; $i <= $total; $i += 1) {
+            $randomId = $i . DBDatetime::now()->getTimestamp();
+            $job = new Job();
+            $job->hydrate((int) $type, (int) $randomId);
+            $service->queueJob($job);
+        }
+    }
+}
diff --git a/src/Queue/ExecutionTime.php b/src/Queue/ExecutionTime.php
new file mode 100644
index 00000000..b3807b12
--- /dev/null
+++ b/src/Queue/ExecutionTime.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Queue;
+
+trait ExecutionTime
+{
+
+    /**
+     * Set PHP max execution time
+     * Skips setting in tests to avoid timeout issues
+     *
+     * @param int $seconds
+     */
+    protected function setMaxExecution(int $seconds): void
+    {
+        ini_set('max_execution_time', $seconds);
+    }
+
+    /**
+     * Get max execution time
+     *
+     * @return int
+     */
+    protected function getMaxExecution(): int
+    {
+        return ini_get('max_execution_time');
+    }
+
+    /**
+     * @param int $executionTime
+     * @param callable $callback
+     * @return mixed
+     */
+    protected function withExecutionTime(int $executionTime, callable $callback)
+    {
+        $originalTime = $this->getMaxExecution();
+
+        try {
+            $this->setMaxExecution($executionTime);
+
+            return $callback();
+        } finally {
+            $this->setMaxExecution($originalTime);
+        }
+    }
+}
diff --git a/src/Queue/Extension.php b/src/Queue/Extension.php
new file mode 100644
index 00000000..80e8fd59
--- /dev/null
+++ b/src/Queue/Extension.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Queue;
+
+use Exception;
+use SilverStripe\Core\ClassInfo;
+use SilverStripe\Core\Extension as BaseExtension;
+use Symbiote\QueuedJobs\DataObjects\QueuedJobDescriptor;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+use Symbiote\QueuedJobs\Services\QueuedJobService;
+use Throwable;
+
+/**
+ * Class Extension
+ *
+ * @property $this|QueuedJobService $owner
+ * @package App\Queue
+ */
+class Extension extends BaseExtension
+{
+
+    /**
+     * Extension point in @see QueuedJobService::runJob()
+     *
+     * @param QueuedJobDescriptor $descriptor
+     * @param QueuedJob $job
+     * @param Throwable|Exception $e
+     */
+    public function updateJobDescriptorAndJobOnException(
+        QueuedJobDescriptor $descriptor,
+        QueuedJob $job,
+        Throwable $e
+    ): void {
+        // capture exception in the messages of the broken job for better debug options
+        $job->addMessage(sprintf('%s : %s', ClassInfo::shortName($e), $e->getMessage()));
+    }
+}
diff --git a/src/Queue/Factory/Job.php b/src/Queue/Factory/Job.php
new file mode 100644
index 00000000..0d4d9628
--- /dev/null
+++ b/src/Queue/Factory/Job.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Queue\Factory;
+
+use App\Queue;
+use SilverStripe\Core\Injector\Injector;
+use SilverStripe\ORM\ValidationException;
+use Symbiote\QueuedJobs\Services\QueuedJobService;
+
+/**
+ * Class Job
+ *
+ * generate jobs based on specification
+ *
+ * @property string $jobClass
+ * @package App\Queue\Factory
+ */
+class Job extends Queue\Job
+{
+
+    public function hydrate(string $jobClass, array $items): void
+    {
+        $this->jobClass = $jobClass;
+        $this->items = $items;
+    }
+
+    public function getTitle(): string
+    {
+        return 'Factory job';
+    }
+
+    /**
+     * @param mixed $item
+     * @throws ValidationException
+     */
+    protected function processItem($item): void
+    {
+        if (!is_array($item) || count($item) === 0) {
+            return;
+        }
+
+        $job = Injector::inst()->create($this->jobClass);
+        $job->hydrate(array_values($item));
+        QueuedJobService::singleton()->queueJob($job);
+    }
+}
diff --git a/src/Queue/Factory/Task.php b/src/Queue/Factory/Task.php
new file mode 100644
index 00000000..1b9a728f
--- /dev/null
+++ b/src/Queue/Factory/Task.php
@@ -0,0 +1,146 @@
+<?php
+
+namespace App\Queue\Factory;
+
+use SilverStripe\Control\HTTPRequest;
+use SilverStripe\Core\Injector\Injector;
+use SilverStripe\Dev\BuildTask;
+use SilverStripe\ORM\DataList;
+use SilverStripe\ORM\ValidationException;
+use Symbiote\QueuedJobs\Services\QueuedJobService;
+
+/**
+ * Class Task
+ *
+ * generic task which creates jobs from id list
+ * each job contains a chunk of the ids
+ * GET param options
+ * size - (int) chunk size
+ * limit - (int) limits the number of IDs processed, test only, defaults to 0 (no limit)
+ * offset - (int) apply offset when using limit
+ * jobs - (int) number of chunks per factory job, setting it 0 skips factory jobs step
+ * used for long execution runs where more than 3000 specified jobs are created
+ *
+ * @package App\Queue\Factory
+ */
+abstract class Task extends BuildTask
+{
+
+    private const FACTORY_JOBS_BATCH_SIZE = 500;
+
+    /**
+     * @param HTTPRequest $request
+     * @param DataList $list
+     * @param string $jobClass
+     * @param int $size
+     * @throws ValidationException
+     */
+    protected function queueJobsFromList(HTTPRequest $request, DataList $list, string $jobClass, int $size): void
+    {
+        $limit = (int) $request->getVar('limit');
+        $offset = (int) $request->getVar('offset');
+
+        if ($limit > 0) {
+            $list = $list->limit($limit, $offset);
+        }
+
+        $ids = $list->columnUnique('ID');
+        $this->queueJobsFromIds($request, $ids, $jobClass, $size);
+    }
+
+    /**
+     * @param HTTPRequest $request
+     * @param array $ids
+     * @param string $jobClass
+     * @param int $size
+     * @throws ValidationException
+     */
+    protected function queueJobsFromIds(HTTPRequest $request, array $ids, string $jobClass, int $size): void
+    {
+        $ids = $this->formatIds($ids);
+        $this->queueJobsFromData($request, $ids, $jobClass, $size);
+    }
+
+    /**
+     * @param HTTPRequest $request
+     * @param array $data
+     * @param string $jobClass
+     * @param int $size
+     * @throws ValidationException
+     */
+    protected function queueJobsFromData(HTTPRequest $request, array $data, string $jobClass, int $size): void
+    {
+        if (count($data) === 0) {
+            return;
+        }
+
+        $jobs = $request->getVar('jobs') ?? self::FACTORY_JOBS_BATCH_SIZE;
+        $jobs = (int) $jobs;
+
+        $chunkSize = (int) $request->getVar('size');
+        $chunkSize = $chunkSize > 0
+            ? $chunkSize
+            : $size;
+
+        $chunks = array_chunk($data, $chunkSize);
+
+        if ($jobs > 0) {
+            $this->createFactoryJobs($chunks, $jobClass, $jobs);
+
+            return;
+        }
+
+        $this->createSpecifiedJobs($chunks, $jobClass);
+    }
+
+    /**
+     * @param array $chunks
+     * @param string $jobClass
+     * @throws ValidationException
+     */
+    private function createSpecifiedJobs(array $chunks, string $jobClass): void
+    {
+        $service = QueuedJobService::singleton();
+
+        foreach ($chunks as $chunk) {
+            $job = Injector::inst()->create($jobClass);
+            $job->hydrate(array_values($chunk));
+            $service->queueJob($job);
+        }
+    }
+
+    /**
+     * @param array $chunks
+     * @param string $jobClass
+     * @param int $chunkSize
+     * @throws ValidationException
+     */
+    private function createFactoryJobs(array $chunks, string $jobClass, int $chunkSize): void
+    {
+        $service = QueuedJobService::singleton();
+        $chunks = array_chunk($chunks, $chunkSize);
+
+        foreach ($chunks as $chunk) {
+            $job = new Job();
+            $job->hydrate($jobClass, array_values($chunk));
+            $service->queueJob($job);
+        }
+    }
+
+    /**
+     * Cast all IDs to int so we don't end up with type errors
+     *
+     * @param array $ids
+     * @return array
+     */
+    private function formatIds(array $ids): array
+    {
+        $formatted = [];
+
+        foreach ($ids as $id) {
+            $formatted[] = (int) $id;
+        }
+
+        return $formatted;
+    }
+}
diff --git a/src/Queue/Job.php b/src/Queue/Job.php
new file mode 100644
index 00000000..f943fea1
--- /dev/null
+++ b/src/Queue/Job.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Queue;
+
+use Symbiote\QueuedJobs\Services\AbstractQueuedJob;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+
+/**
+ * Class Job
+ *
+ * This job represent a generic job which consumes items and each item is processed in one step
+ * useful as a template for jobs which need to process multiple items
+ * item can be an arbitrary piece of data for example: ID or array
+ *
+ * @property array $items
+ * @property array $remaining
+ * @package App\Queue
+ */
+abstract class Job extends AbstractQueuedJob
+{
+
+    public function getJobType(): int
+    {
+        return QueuedJob::QUEUED;
+    }
+
+    public function setup(): void
+    {
+        $this->remaining = $this->items;
+        $this->totalSteps = count($this->items);
+    }
+
+    public function process(): void
+    {
+        $remaining = $this->remaining;
+
+        // check for trivial case
+        if (count($remaining) === 0) {
+            $this->isComplete = true;
+
+            return;
+        }
+
+        $item = array_shift($remaining);
+
+        $this->processItem($item);
+
+        // update job progress
+        $this->remaining = $remaining;
+        $this->currentStep += 1;
+
+        // check for job completion
+        if (count($remaining) > 0) {
+            return;
+        }
+
+        $this->isComplete = true;
+    }
+
+    /**
+     * @param mixed $item
+     */
+    abstract protected function processItem($item): void;
+}
diff --git a/src/Queue/Logger.php b/src/Queue/Logger.php
new file mode 100644
index 00000000..d0649f46
--- /dev/null
+++ b/src/Queue/Logger.php
@@ -0,0 +1,83 @@
+<?php
+
+namespace App\Queue;
+
+use Psr\Log\LoggerInterface;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+
+/**
+ * Class Logger
+ *
+ * This logger redirects all log messages to the queued job which makes the job data contain all relevant logs
+ *
+ * @package App\Queue
+ */
+class Logger implements LoggerInterface
+{
+
+    /**
+     * @var QueuedJob|null
+     */
+    private $job = null;
+
+    public function setJob(?QueuedJob $job): void
+    {
+        $this->job = $job;
+    }
+
+    public function debug($message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    public function critical($message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    public function alert($message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    public function log($level, $message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    public function emergency($message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    public function warning($message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    public function error($message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    public function notice($message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    public function info($message, array $context = []): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $this->logJobMessage($message);
+    }
+
+    private function logJobMessage(string $message): void
+    {
+        $job = $this->job;
+
+        if (!$job instanceof QueuedJob) {
+            return;
+        }
+
+        $job->addMessage($message);
+    }
+}
diff --git a/src/Queue/Management/Report.php b/src/Queue/Management/Report.php
new file mode 100644
index 00000000..213ad440
--- /dev/null
+++ b/src/Queue/Management/Report.php
@@ -0,0 +1,279 @@
+<?php
+
+namespace App\Queue\Management;
+
+use SilverStripe\Control\HTTPRequest;
+use SilverStripe\Dev\BuildTask;
+use SilverStripe\ORM\FieldType\DBDatetime;
+use SilverStripe\ORM\Queries\SQLSelect;
+use Symbiote\QueuedJobs\DataObjects\QueuedJobDescriptor;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+use Symbiote\QueuedJobs\Services\QueuedJobService;
+
+/**
+ * Class Report
+ *
+ * Queue state overview report
+ *
+ * @package App\Queue\Management
+ */
+class Report extends BuildTask
+{
+
+    /**
+     * {@inheritDoc}
+     *
+     * @var string
+     */
+    private static $segment = 'queue-management-report';
+
+    /**
+     * @return string
+     */
+    public function getDescription(): string
+    {
+        return 'Overall queued jobs completion progress';
+    }
+
+    /**
+     * @param HTTPRequest $request
+     */
+    public function run($request): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        $now = DBDatetime::now()->Rfc2822();
+        $service = QueuedJobService::singleton();
+        $queueState = [];
+
+        if ($service->isMaintenanceLockActive()) {
+            $queueState[] = 'Paused';
+        }
+
+        if ($service->isAtMaxJobs()) {
+            $queueState[] = 'Maximum init jobs';
+        }
+
+        $queueState = $queueState
+            ? implode(' ', $queueState)
+            : 'Running';
+
+        // job states
+        $query = SQLSelect::create(
+            '`JobStatus`, COUNT(`JobStatus`) as `count`',
+            'QueuedJobDescriptor',
+            ['StartAfter IS NULL OR StartAfter <= ?' => $now],
+            ['count' => 'DESC'],
+            ['JobStatus']
+        );
+
+        $results = $query->execute();
+        $totalJobs = 0;
+
+        $jobsData = [];
+
+        while ($result = $results->next()) {
+            $status = $result['JobStatus'];
+            $count = $result['count'];
+            $jobsData[$status] = $count;
+            $totalJobs+= $count;
+        }
+
+        $brokenJobs = array_key_exists(QueuedJob::STATUS_BROKEN, $jobsData)
+            ? $jobsData[QueuedJob::STATUS_BROKEN]
+            : 0;
+        $newsJobs = array_key_exists(QueuedJob::STATUS_NEW, $jobsData)
+            ? $jobsData[QueuedJob::STATUS_NEW]
+            : 0;
+        $initJobs = array_key_exists(QueuedJob::STATUS_INIT, $jobsData)
+            ? $jobsData[QueuedJob::STATUS_INIT]
+            : 0;
+        $runningJobs = array_key_exists(QueuedJob::STATUS_RUN, $jobsData)
+            ? $jobsData[QueuedJob::STATUS_RUN]
+            : 0;
+        $completedJobs = array_key_exists(QueuedJob::STATUS_COMPLETE, $jobsData)
+            ? $jobsData[QueuedJob::STATUS_COMPLETE]
+            : 0;
+        $jobsInProgress = $newsJobs + $initJobs + $runningJobs;
+
+        $queueState = $queueState === 'Running' && $jobsInProgress === 0
+            ? 'Idle'
+            : $queueState;
+
+        // progress bar
+        echo sprintf(
+            '<h2>[%s] Job progress %0.2f%%</h2>',
+            $queueState,
+            $totalJobs > 0 ? (($totalJobs - $jobsInProgress) / $totalJobs) * 100 : 0
+        );
+
+        $barWidth = 1000;
+        echo sprintf(
+            '<div style="background-color: white; height: 40px; width: %dpx; border: thin solid black">',
+            $barWidth
+        );
+
+        foreach (['lime' => $completedJobs, 'red' => $brokenJobs] as $color => $count) {
+            echo sprintf(
+                '<div title="%d" style="background-color: %s; height: 100%%; width: %0.2fpx; display: inline-block">'
+                . '</div>',
+                $count,
+                $color,
+                $totalJobs > 0 ? ($count / $totalJobs) * $barWidth : 0
+            );
+        }
+
+        echo '</div>';
+
+        echo '<h3>Job status breakdown</h3>';
+
+        foreach ($jobsData as $status => $count) {
+            if (!$count) {
+                continue;
+            }
+
+            echo sprintf('<p><b>%d</b> - %s</p>', $count, $status);
+        }
+
+        echo sprintf('<p><b>%d</b> - Total</p>', $totalJobs);
+
+        // first and last completed job
+        $query = SQLSelect::create(
+            'MAX(`JobFinished`) as `last_job`, MIN(`JobStarted`) as `first_job`',
+            'QueuedJobDescriptor',
+            [['JobStatus' => QueuedJob::STATUS_COMPLETE]]
+        );
+
+        $results = $query->execute();
+        $result = $results->first();
+        $firstJob = $result['first_job'] ?? '';
+        $lastJob = $result['last_job'] ?? '';
+
+        // total job duration
+        $query = SQLSelect::create(
+            sprintf(
+                '`JobTitle`, SUM(UNIX_TIMESTAMP(`JobFinished`) - UNIX_TIMESTAMP(%s) as `duration`, COUNT(*) as `count`',
+                'COALESCE(`JobRestarted`, `JobStarted`))'
+            ),
+            'QueuedJobDescriptor',
+            [['JobStatus' => QueuedJob::STATUS_COMPLETE]],
+            ['duration' => 'DESC'],
+            ['JobTitle']
+        );
+
+        $results = $query->execute();
+
+        $totalDuration = 0;
+        $jobDurations = [];
+        $jobTypesCompleted = [];
+        $jobQueueTypeCompleted = [];
+
+        while ($result = $results->next()) {
+            $jobType = $result['JobTitle'];
+            $duration = $result['duration'];
+            $totalDuration += $duration;
+
+            $jobDurations[$jobType] = $duration;
+
+            $count = $result['count'];
+            $jobTypesCompleted[$jobType] = $count;
+        }
+
+        // total job duration
+        $query = SQLSelect::create(
+            'JobType, COUNT(*) as `count`',
+            'QueuedJobDescriptor',
+            [['JobStatus' => QueuedJob::STATUS_COMPLETE]],
+            [],
+            ['JobType']
+        );
+
+        $results = $query->execute();
+
+        while ($result = $results->next()) {
+            $jobType = $result['JobType'];
+            $count = $result['count'];
+
+            $jobQueueTypeCompleted[$jobType] = $count;
+        }
+
+        $elapsed = 0;
+
+        if ($totalDuration > 0) {
+            echo sprintf('<p><b>%d</b> s - total job duration</p>', $totalDuration);
+            echo sprintf('<p><b>%0.4f</b> s - average job duration</p>', $totalDuration / $completedJobs);
+            echo sprintf('<p><b>%s</b> - first job</p>', $firstJob);
+            echo sprintf('<p><b>%s</b> - last job</p>', $lastJob);
+
+            $elapsed = strtotime($lastJob) - strtotime($firstJob);
+            echo sprintf('<p><b>%s</b> - elapsed time (s)</p>', $elapsed);
+        } else {
+            echo '<p>No completed jobs found</p>';
+        }
+
+        echo '<h3>Durations by job type</h3>';
+
+        foreach ($jobDurations as $jobType => $duration) {
+            $jobType = $jobType ?: 'Unknown';
+
+            echo sprintf('<p><b>%d</b> s - %s</p>', $duration, $jobType);
+        }
+
+        echo '<h3>Completed jobs by job type</h3>';
+
+        foreach ($jobTypesCompleted as $jobType => $completed) {
+            $jobType = $jobType ?: 'Unknown';
+
+            echo sprintf('<p><b>%d</b> jobs - %s</p>', $completed, $jobType);
+        }
+
+        echo '<h3>Completed jobs by queue type</h3>';
+
+        $queueTypes = QueuedJobDescriptor::singleton()->getJobTypeValues();
+
+        foreach ($jobQueueTypeCompleted as $jobType => $completed) {
+            $jobType = $jobType ?: QueuedJob::QUEUED;
+
+            echo sprintf('<p><b>%d</b> - %s</p>', $completed, $queueTypes[(string) $jobType]);
+        }
+
+        echo '<h3>Seconds per completed job by job type</h3>';
+
+        foreach ($jobDurations as $jobType => $duration) {
+            $completed = (int) $jobTypesCompleted[$jobType];
+            $jobType = $jobType ?: 'Unknown';
+
+            echo sprintf('<p><b>%f</b> s/job - %s</p>', ($duration / $completed), $jobType);
+        }
+
+        echo '<h3>Completed jobs per elapsed second by job type</h3>';
+
+        if ($elapsed) {
+            foreach ($jobTypesCompleted as $jobType => $completed) {
+                $jobType = $jobType ?: 'Unknown';
+
+                echo sprintf('<p><b>%f</b> jobs/elapsed second - %s</p>', ($completed / $elapsed), $jobType);
+            }
+        }
+
+        // job type breakdown
+        $query = SQLSelect::create(
+            '`JobTitle`, COUNT(`JobTitle`) as `count`',
+            'QueuedJobDescriptor',
+            ['StartAfter IS NULL OR StartAfter <= ?' => $now],
+            ['count' => 'DESC'],
+            ['JobTitle']
+        );
+
+        $results = $query->execute();
+        echo '<h3>Job type breakdown</h3>';
+
+        while ($result = $results->next()) {
+            $count = $result['count'];
+
+            if (!$count) {
+                continue;
+            }
+
+            echo sprintf('<p><b>%d</b> - %s</p>', $count, $result['JobTitle']);
+        }
+    }
+}
diff --git a/src/Queue/Management/Task.php b/src/Queue/Management/Task.php
new file mode 100644
index 00000000..da678ce9
--- /dev/null
+++ b/src/Queue/Management/Task.php
@@ -0,0 +1,176 @@
+<?php
+
+namespace App\Queue\Management;
+
+use SilverStripe\Control\HTTPRequest;
+use SilverStripe\Dev\BuildTask;
+use SilverStripe\ORM\DB;
+use SilverStripe\ORM\Queries\SQLSelect;
+use SilverStripe\ORM\Queries\SQLUpdate;
+use Symbiote\QueuedJobs\DataObjects\QueuedJobDescriptor;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+
+/**
+ * Class Task
+ *
+ * Tool for changing job statuses
+ *
+ * @package App\Queue\Management
+ */
+class Task extends BuildTask
+{
+
+    /**
+     * @var string
+     */
+    private static $segment = 'queue-management-job-status';
+
+    /**
+     * @return string
+     */
+    public function getDescription(): string
+    {
+        return 'Update job status for specific job type';
+    }
+
+    /**
+     * @param HTTPRequest $request
+     */
+    public function run($request): void // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        /** @var QueuedJobDescriptor $job */
+        $job = QueuedJobDescriptor::singleton();
+        $statuses = $job->getJobStatusValues();
+        sort($statuses, SORT_STRING);
+
+        $currentStatuses = array_diff($statuses, [
+            QueuedJob::STATUS_COMPLETE,
+        ]);
+
+        // job implementations
+        $query = SQLSelect::create(
+            'DISTINCT `Implementation`',
+            'QueuedJobDescriptor',
+            ['`JobStatus` != ?' => QueuedJob::STATUS_COMPLETE],
+            ['Implementation' => 'ASC']
+        );
+
+        $results = $query->execute();
+
+        $implementations = [];
+
+        // Add job types
+        while ($result = $results->next()) {
+            $implementation = $result['Implementation'];
+
+            if (!$implementation) {
+                continue;
+            }
+
+            $implementations[] = $result['Implementation'];
+        }
+
+        if (count($implementations) === 0) {
+            echo 'No job implementations found.';
+
+            return;
+        }
+
+        $implementation = $request->postVar('implementation');
+        $currentStatus = $request->postVar('currentStatus');
+        $status = $request->postVar('status');
+
+        if ($implementation
+            && $status
+            && ($implementation === 'all' || in_array($implementation, $implementations))
+            && ($currentStatus === 'any' || in_array($currentStatus, $currentStatuses))
+            && in_array($status, $statuses)
+        ) {
+            $where = [
+                ['`JobStatus` != ?' => QueuedJob::STATUS_COMPLETE],
+            ];
+
+            // Filter by implementation
+            $where[] = $implementation === 'all'
+                ? '`Implementation` IN ' . sprintf(
+                    "('%s')",
+                    str_replace('\\', '\\\\', implode("','", $implementations))
+                )
+                : ['`Implementation`' => $implementation];
+
+            // Filter by status
+            if ($currentStatus !== 'any') {
+                $where[] = ['`JobStatus`' => $currentStatus];
+            }
+
+            // Assemble query
+            $query = SQLUpdate::create(
+                'QueuedJobDescriptor',
+                [
+                    'JobStatus' => $status,
+                    // make sure to reset all data which is related to job management
+                    // job lock
+                    'Worker' => null,
+                    'Expiry' => null,
+                    // resume / pause
+                    'ResumeCounts' => 0,
+                    // broken job notification
+                    'NotifiedBroken' => 0,
+                ],
+                $where
+            );
+
+            $query->execute();
+
+            echo sprintf('Job status updated (%d rows affected).', DB::affected_rows());
+
+            return;
+        }
+
+        echo '<form action="" method="post">';
+
+        echo '<p>Job type</p>';
+
+        echo '<select name="implementation">';
+        echo '<option value="all">All job types</option>';
+
+        foreach ($implementations as $item) {
+            echo sprintf('<option value="%s">%s</option>', $item, $item);
+        }
+
+        echo '</select>';
+
+        echo '<br />';
+
+        echo '<p>Current status</p>';
+
+        echo '<select name="currentStatus">';
+        echo '<option value="any">Any status (except Complete)</option>';
+
+        foreach ($currentStatuses as $item) {
+            echo sprintf('<option value="%s">%s</option>', $item, $item);
+        }
+
+        echo '</select>';
+
+        echo '<br />';
+
+        echo '<p>Update status to</p>';
+
+        echo '<select name="status">';
+
+        foreach ($statuses as $item) {
+            echo sprintf('<option value="%s">%s</option>', $item, $item);
+        }
+
+        echo '</select>';
+
+        echo '<br />';
+
+        echo '<br />';
+
+        echo 'Submitting will apply change immediately:<br><br>';
+        echo '<button type="submit">Update status</button>';
+        echo '</form>';
+    }
+}
diff --git a/src/Queue/Manager.php b/src/Queue/Manager.php
new file mode 100644
index 00000000..5753321c
--- /dev/null
+++ b/src/Queue/Manager.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Queue;
+
+use AsyncPHP\Doorman\Manager\ProcessManager;
+
+/**
+ * Class Manager
+ *
+ * customise shell command to allow child tasks to persist even after manager process is terminated
+ * this lets the started jobs to finish properly in case the management process terminates
+ * fore example there are no more jobs to start or queue is paused
+ *
+ * @package App\Queue
+ */
+class Manager extends ProcessManager
+{
+
+    /**
+     * @param string $binary
+     * @param string $worker
+     * @param string $stdout
+     * @param string $stderr
+     * @return string
+     */
+    protected function getCommand($binary, $worker, $stdout, $stderr) // phpcs:ignore SlevomatCodingStandard.TypeHints
+    {
+        return sprintf('nohup %s %s %%s %s %s & echo $!', $binary, $worker, $stdout, $stderr);
+    }
+
+    public function __destruct()
+    {
+        // Prevent background tasks from being killed when this script finishes
+        // this is an override for the default behaviour of killing background tasks
+    }
+}
diff --git a/src/Queue/QueuedJobServiceExtension.php b/src/Queue/QueuedJobServiceExtension.php
new file mode 100644
index 00000000..677d66c4
--- /dev/null
+++ b/src/Queue/QueuedJobServiceExtension.php
@@ -0,0 +1,110 @@
+<?php
+
+namespace App\Extensions\QueuedJobs;
+
+use Exception;
+use SilverStripe\Core\Extension;
+use SilverStripe\ORM\FieldType\DBDatetime;
+use Symbiote\QueuedJobs\DataObjects\QueuedJobDescriptor;
+use Symbiote\QueuedJobs\Services\QueuedJob;
+use Symbiote\QueuedJobs\Services\QueuedJobService;
+use Throwable;
+
+/**
+ * Class QueuedJobServiceExtension
+ *
+ * @property $this|QueuedJobService $owner
+ * @package App\Extensions\QueuedJobs
+ */
+class QueuedJobServiceExtension extends Extension
+{
+    /**
+     *  Retry delay configuration
+     * <retry_attempt> => <time_delay>
+     */
+    const RETRY_INTERVALS = [
+        1 => 60, // 1 minute
+        2 => 4 * 60, // 4 minutes
+        3 => 10 * 60, // 10 minutes
+        4 => 30 * 60, // 30 minutes
+        5 => 60 * 60, // 1 hour
+    ];
+
+    /**
+     * This extension point is invoked by QueuedJobService any time an Exception is thrown as part of runJob().
+     * QueuedJobService (prior to invoking this extension) has set the JobStatus to STATUS_BROKEN - this extension point
+     * grants us an opportunity to reset this JobStatus back to STATUS_NEW (so that the job will retry) if we have met
+     * certain criteria.
+     * extension point in @see QueuedJobService::runJob()
+     *
+     * @param QueuedJobDescriptor|QueuedJobDescriptorExtension $descriptor
+     * @param QueuedJob $job
+     * @param Throwable|Exception $e
+     */
+    public function updateJobDescriptorAndJobOnException(
+        QueuedJobDescriptor $descriptor,
+        QueuedJob $job,
+        Throwable $e
+    ): void {
+        $descriptor->FailedAttempts += 1;
+
+        // If the Job has already tried to process our maximum number of times, then leave it as STATUS_BROKEN.
+        if ($descriptor->FailedAttempts > QueuedJobDescriptor::config()->get('max_retry_attempts')) {
+            // The job no longer gets retried - add specific logging here
+
+            return;
+        }
+
+        // If the Job is not a type that supports retrying, then leave it as STATUS_BROKEN.
+        if (!in_array(get_class($job), QueuedJobDescriptor::config()->get('allowed_retry_jobs'))) {
+            // The job doesn't get retried at all - add specific logging here
+
+            return;
+        }
+
+        // We should retry this Job.
+        $descriptor->JobStatus = QueuedJob::STATUS_NEW;
+
+        // add a random delay so we wouldn't retry the job immediately, but with some spread
+        // this lowers the chance of multiple jobs accessing the same data, thus preventing conflicts
+        $descriptor->StartAfter = static::randomiseStartAfter($descriptor->FailedAttempts);
+
+        // release the job lock so it could be picked up again
+        $descriptor->Worker = null;
+        $descriptor->Expiry = null;
+    }
+
+    /**
+     * @param int $attempts
+     * @return int
+     */
+    public static function randomiseStartAfter(int $attempts): int
+    {
+        $now = DBDatetime::now();
+        $time = $now->getTimestamp();
+
+        $intervals = static::RETRY_INTERVALS;
+
+        if (!array_key_exists($attempts, $intervals)) {
+            return $time;
+        }
+
+        $previousDuration = 0;
+        $currentDuration = 0;
+
+        foreach ($intervals as $retries => $duration) {
+            if ($retries === $attempts) {
+                $currentDuration = $duration;
+
+                break;
+            }
+
+            $previousDuration += $duration;
+        }
+
+        $delay = mt_rand($previousDuration, $previousDuration + $currentDuration);
+        $time += $delay;
+
+        return $time;
+    }
+}
diff --git a/src/Queue/batch-state-update.png b/src/Queue/batch-state-update.png
new file mode 100644
index 00000000..b92fdf7f
Binary files /dev/null and b/src/Queue/batch-state-update.png differ
diff --git a/src/Queue/job-admin.png b/src/Queue/job-admin.png
new file mode 100644
index 00000000..685a07ca
Binary files /dev/null and b/src/Queue/job-admin.png differ
diff --git a/src/Queue/job-edit-form.png b/src/Queue/job-edit-form.png
new file mode 100644
index 00000000..8dda6ab2
Binary files /dev/null and b/src/Queue/job-edit-form.png differ
diff --git a/src/Queue/job-messages.png b/src/Queue/job-messages.png
new file mode 100644
index 00000000..7c3c70e8
Binary files /dev/null and b/src/Queue/job-messages.png differ
diff --git a/src/Queue/overview-report.png b/src/Queue/overview-report.png
new file mode 100644
index 00000000..deaecd5a
Binary files /dev/null and b/src/Queue/overview-report.png differ