Cron Tasks

Schedule automated tasks to run periodically.

Cron Task Interface

<?php
namespace Plugins\MyPlugin\CronTask;

use App\Core\Cron\PluginCronTaskInterface;
use Psr\Log\LoggerInterface;

class MyCleanupTask implements PluginCronTaskInterface
{
    public function __construct(
        private readonly MyService $myService,
        private readonly LoggerInterface $logger,
    ) {}

    public function execute(): void
    {
        $this->logger->info('Running cleanup task');

        try {
            $deletedCount = $this->myService->cleanupOldData();

            $this->logger->info('Cleanup completed', [
                'deleted_count' => $deletedCount
            ]);
        } catch (\Exception $e) {
            $this->logger->error('Cleanup failed', [
                'error' => $e->getMessage()
            ]);

            throw $e;
        }
    }

    public function getSchedule(): string
    {
        // Cron expression
        return '0 3 * * *';  // Daily at 3 AM
    }

    public function getName(): string
    {
        return 'my-plugin:cleanup';
    }

    public function getDescription(): string
    {
        return 'Clean up old data from my-plugin tables';
    }

    public function isEnabled(): bool
    {
        // Control whether task should run
        return true;
    }
}

Cron Expression Syntax

Expression	Meaning	When it runs
* * * * *	Every minute	Every minute
*/5 * * * *	Every 5 minutes	:00, :05, :10, ...
0 * * * *	Every hour	Top of every hour
0 */6 * * *	Every 6 hours	00:00, 06:00, 12:00, 18:00
0 3 * * *	Daily at 3 AM	Once per day
0 0 * * 0	Weekly on Sunday	Sunday at midnight
0 0 1 * *	Monthly on 1st	First day of month

Cron Expression Format

*    *    *    *    *
┬    ┬    ┬    ┬    ┬
│    │    │    │    │
│    │    │    │    └─── Day of Week   (0-6) (Sunday=0)
│    │    │    └──────── Month          (1-12)
│    │    └───────────── Day of Month   (1-31)
│    └────────────────── Hour           (0-23)
└─────────────────────── Minute         (0-59)

Advanced Cron Task

class AdvancedTask implements PluginCronTaskInterface
{
    public function execute(): void
    {
        $startTime = microtime(true);

        // Task logic
        $this->myService->performTask();

        $duration = microtime(true) - $startTime;

        $this->logger->info('Task completed', [
            'duration' => $duration,
            'memory' => memory_get_peak_usage(true)
        ]);
    }

    public function isEnabled(): bool
    {
        // Only run if plugin setting is enabled
        $enabled = $this->pluginSettings->get('my-plugin', 'cron_enabled', false);
        return (bool) $enabled;
    }
}

Service Registration

services:
    Plugins\MyPlugin\CronTask\MyCleanupTask:
        tags: ['plugin.cron_task']

Important: Cron tasks must be tagged with plugin.cron_task.

Task Examples

Daily Database Cleanup

class DatabaseCleanupTask implements PluginCronTaskInterface
{
    public function execute(): void
    {
        // Delete logs older than 30 days
        $cutoffDate = new \DateTimeImmutable('-30 days');

        $deleted = $this->repository
            ->createQueryBuilder('l')
            ->delete()
            ->where('l.createdAt < :cutoff')
            ->setParameter('cutoff', $cutoffDate)
            ->getQuery()
            ->execute();

        $this->logger->info('Cleaned up old logs', ['deleted' => $deleted]);
    }

    public function getSchedule(): string
    {
        return '0 2 * * *';  // Daily at 2 AM
    }
}

Hourly Data Sync

class DataSyncTask implements PluginCronTaskInterface
{
    public function execute(): void
    {
        // Sync data with external API
        $data = $this->externalApi->fetchLatestData();

        foreach ($data as $item) {
            $this->processDataItem($item);
        }

        $this->logger->info('Data sync completed', ['items' => count($data)]);
    }

    public function getSchedule(): string
    {
        return '0 * * * *';  // Every hour
    }
}

Weekly Report Generation

class WeeklyReportTask implements PluginCronTaskInterface
{
    public function execute(): void
    {
        // Generate weekly statistics
        $stats = $this->statsService->generateWeeklyReport();

        // Send email to admins
        $this->mailer->sendWeeklyReport($stats);

        $this->logger->info('Weekly report sent');
    }

    public function getSchedule(): string
    {
        return '0 9 * * 1';  // Every Monday at 9 AM
    }
}

Error Handling

public function execute(): void
{
    try {
        $this->performTask();
    } catch (\Exception $e) {
        $this->logger->error('Cron task failed', [
            'task' => $this->getName(),
            'error' => $e->getMessage(),
            'trace' => $e->getTraceAsString()
        ]);

        // Optionally notify admins
        $this->notifyAdmins($e);

        // Re-throw to mark task as failed
        throw $e;
    }
}

Conditional Execution

public function isEnabled(): bool
{
    // Check plugin setting
    $enabled = $this->pluginSettings->get('my-plugin', 'sync_enabled');
    if (!$enabled) {
        return false;
    }

    // Check system status
    if ($this->systemStatus->isMaintenanceMode()) {
        return false;
    }

    // Check time-based conditions
    $hour = (int) date('H');
    if ($hour >= 9 && $hour <= 17) {
        // Don't run during business hours
        return false;
    }

    return true;
}

Best Practices

1. Keep tasks fast - they block other tasks

2. Handle errors gracefully - don't let exceptions break cron

3. Log execution - track when tasks run and their results

4. Use appropriate schedules - don't run tasks more often than needed

5. Make tasks idempotent - safe to run multiple times

6. Check isEnabled() - allow users to disable tasks

7. Monitor performance - track execution time and memory

8. Batch operations - process data in chunks to avoid memory issues

Monitoring Cron Tasks

Check task execution:

docker exec pteroca_web_dev php bin/console pteroca:cron:list
docker exec pteroca_web_dev php bin/console pteroca:cron:run my-plugin:cleanup --dry-run

Related Guides

• Console Commands - Manual task execution

• Dependencies - Service injection

• Best Practices - Performance optimization