Scheduled Task Details

The Scheduled Task Details resource provides a two-tiered view:

A summary of the scheduled task itself (schedule, status, timing, and performance metrics).
A paginated list of historical runs for that task, with filtering and per-run drill-down into a full event timeline (similar to Request and Command Details).

Navigation: Click the View icon (👁️) next to any task in the Scheduled Tasks index to open this page.

1. Scheduled Task Summary Grid

At the top of the page, a compact grid displays all of the essential metadata for the selected scheduled task:

Scheduled Task
The task’s identifier—typically the Artisan command signature or custom name (e.g., backup:run, emails:send-digest).
Status
Current health state of the task, based on its most recent run:
- HEALTHY: Last run completed successfully within acceptable duration.
- WAITING: Task is scheduled for a future run and has not yet started.
- SKIPPED: The task missed its scheduled run (e.g., scheduler was offline).
- FAILED: The last run ended with a non-zero exit code or threw an unhandled exception.
Last Run
Timestamp when the task last executed. If the task has never run, this field may be blank or show “—”.
Next Run
Predicted timestamp for the upcoming execution based on the configured schedule.
Schedule
The CRON expression or human-readable schedule (e.g., */5 * * * *, daily at 02:00).
Avg. Duration
The average execution time across all recorded runs, in milliseconds.

This summary grid gives you an immediate, high-level picture of the task’s health and performance.

2. Runs Section: Historical Execution List

Below the summary grid, you will find the Runs section—an index table that lists each historical execution (run) of this scheduled task. Runs are ordered by Scheduled At in descending order (most recent first), with pagination to load additional entries.

2.1 Runs Index Table

Ordering: By default, entries are sorted by Scheduled At in descending order.
Pagination: The table displays 50 results at a time. Click Load More at the bottom to load the next batch of historical runs.

2.1.1 Columns

Scheduled At
- Timestamp indicating when the task was scheduled to run.
Started At
- Timestamp when Laritor recorded the actual start of this run. If the scheduler was down at the scheduled time, this may be later than Scheduled At or blank if never started.
Completed At
- Timestamp when the run finished. Blank if still in progress or if the run never started.
Duration
- Total execution time for this run, in milliseconds.
Status
- Health outcome of this run:
  - HEALTHY (exit code 0)
  - FAILED (non-zero exit code or unhandled exception)
  - SKIPPED (scheduled but did not execute)
  - WAITING (scheduled and waiting to start)
View Icon (👁️)
- Click to open the Scheduled Task Run Details view for this specific execution.

Note: If a run remains in a “WAITING” state for an extended period, it may indicate the scheduler was paused or the server was overloaded.

2.2 Runs Filters

Above the Runs table, a set of filter controls allows you to refine which runs are displayed:

Date & Time Range
- Select a Start Date & Time and End Date & Time to limit runs to a specific window (based on Scheduled At).
Duration
- A numeric input (milliseconds) to filter runs whose execution time is above or below a given threshold.
Status Dropdown
- Filter runs by health state (HEALTHY, WAITING, SKIPPED, FAILED).

Tip: Combine a narrow time window with the FAILED status to quickly locate problematic runs that occurred during a specific period.

2.3 Load More

By default, the Runs table shows the 50 most recent executions.
Click Load More to append the next 50 runs, ordered by Scheduled At.
This incremental loading mechanism ensures fast page load times while still providing access to the complete run history.

3. Scheduled Task Run Details

Clicking the View icon (👁️) for any historical run opens the Scheduled Task Run Details page. This view follows the same layout and structure as Request Details and Command Details, with a header grid and a tabbed event timeline.

3.1 Run Header Grid: Run Metadata

At the top of the Run Details page, a summary grid displays all of the key metrics and identifying fields for this specific execution:

Scheduled Task
The task identifier (e.g., backup:run).
Status
Health outcome for this run (HEALTHY, FAILED, SKIPPED, or WAITING).
Scheduled At
Timestamp when the run was supposed to start.
Started At
Timestamp when execution actually began. Blank if never started.
Completed At
Timestamp when execution finished. Blank if still in progress or skipped.
Duration
Total run time, in milliseconds.

The header grid gives you a concise overview of this run’s lifecycle, enabling you to immediately spot runs that never started, hung, or failed.

Below the run header grid, a tabbed interface presents all events and side effects that occurred during this run. By default, the Timeline tab is active. Tabs include:

Timeline (default)
Queries
Exceptions
Outbound Requests
Cache
Jobs
Logs
Mails
Notifications

Clicking any tab filters the view to that event category, allowing you to investigate the specific actions that took place during the run.

3.2.1 Timeline Tab

The Timeline tab chronicles each phase of the scheduled task run in the order it occurred:

Scheduled Task Started
- Displayed on the left, with a timestamp on the right indicating when execution began.
Bootstrap
- Labeled “Bootstrap” on the left, with the total bootstrap duration on the right (e.g., 20 ms).
- Lists each initialization event (service provider registrations, configuration loading, IoC container setup) in chronological order beneath the phase header.
Scheduled Task Execution
- Labeled “Scheduled Task Execution” on the left, with the total command/runtime duration on the right (e.g., 3,500 ms).
- All events triggered during the task’s main logic are listed here in the order they occurred, including:
  - Queries (SQL statements executed)
  - Cache (cache interactions: hits, misses, writes)
  - Exceptions (if any exceptions were thrown and caught)
  - Outbound Requests (HTTP calls to external services)
  - Jobs (jobs dispatched to queues)
  - Logs (log messages generated during execution)
  - Mails (emails sent via Laravel Mailables)
  - Notifications (notifications dispatched through Laravel channels)
- Each event is represented by an icon (e.g., SQL icon, cache icon, job icon) and a short description, with any associated durations or status indicators.
Scheduled Task Completed
- Shown on the left with a timestamp on the right indicating when the run finished.
- If the status is FAILED, this section may show an error badge or exit code indicator.

Timeline Event Types

Queries: Detailed SQL statements, bindings (if recorded), and individual durations.
Cache: Cache key names, hit/miss status, and durations.
Exceptions: Exception class, message, stack trace (collapsed by default).
Outbound Requests: HTTP method, target URL, status code, and duration.
Jobs: Job class names, queue metadata, and enqueue timestamps.
Logs: Log level, message, and any contextual metadata.
Mails: Mailable class, recipients, and subject lines.
Notifications: Notification class, channels, and recipients.

Icons, color coding, and duration badges make it easy to identify bottlenecks (long-running queries, repeated cache misses, or external calls) and pinpoint exactly where a failure occurred.

3.2.2 Queries Tab

Lists every database query executed during this run, in chronological order:

Timestamp (relative or absolute)
Query Text (raw SQL)
Bindings (if captured)
Duration (in milliseconds)
Connection Name (if multiple connections exist)

Use this tab to identify slow or inefficient queries within the scheduled task’s logic.

3.2.3 Exceptions Tab

If any exception was thrown during this run, it appears here:

Timestamp
Exception Class & Message
Stack Trace (collapsed by default; click to expand)
File & Line Number

Quickly locate unhandled errors or inspect the full stack trace to find the root cause of failure.

3.2.4 Outbound Requests Tab

Lists all HTTP requests made by the scheduled task to external services:

Timestamp
HTTP Method & URL
Status Code returned by the external endpoint
Duration (time taken to complete the request)
Response Size (if recorded)

Use this information to troubleshoot slow or failing third-party integrations invoked by the task.

3.2.5 Cache Tab

Displays all cache operations performed during the run:

Timestamp
Type (e.g., Cache Hit, Cache Miss, Cache Write)
Cache Key (e.g., reports:daily_summary)
Duration (if measurable)
Hit/Miss Indicator

Review this tab to confirm that caching behaves as expected and to identify unnecessary cache misses.

3.2.6 Jobs Tab

Shows every job dispatched during this scheduled task run:

Timestamp
Job Class Name (e.g., GenerateReportJob)
Queue Name (e.g., high-priority)
Payload Metadata (if recorded)

Ensure that background jobs are enqueued correctly as part of the task’s workflow.

3.2.7 Logs Tab

Lists all log entries generated during the run:

Timestamp
Log Level (e.g., INFO, ERROR, DEBUG)
Log Message
Context Data (if provided)

Use this tab to correlate informational or error messages with specific points in the timeline.

3.2.8 Mails Tab

Tracks all emails sent by the task:

Timestamp
Mailable Class (e.g., DailySummaryMail)
Recipient Address(es)
Subject Line

Verify that any scheduled or triggered emails were dispatched as intended.

3.2.9 Notifications Tab

Displays notifications sent via Laravel’s notification channels:

Timestamp
Notification Class (e.g., MaintenanceModeNotification)
Channels (e.g., mail, database)
Recipient (user ID or model)

Confirm that user notifications or administrative alerts were triggered correctly during the run.

4. Best Practices & Troubleshooting

Monitor Recent Failures First
If the Status of this run is FAILED, immediately check the Exceptions and Logs tabs to identify the error and its cause. Use the timeline to see exactly when within the task’s flow the failure occurred.
Validate Scheduling Accuracy
Compare Scheduled At and Started At timestamps. If there is a significant delay between those two fields for multiple runs, ensure that the scheduler (cron or queue worker) is running reliably on your server.
Analyze Duration Trends
Use the Queries and Outbound Requests tabs to find expensive database operations or external calls that are lengthening run times. This can guide you to add indexes, batch queries, or cache results.
Verify Cache Efficiency
Frequent cache misses can slow down a scheduled task that relies on cached data. Use the Cache tab to adjust cache keys or increase TTLs to reduce repeated misses.
Confirm Job Enqueues
If the scheduled task’s primary purpose is to queue up background jobs, check the Jobs tab to ensure that jobs were enqueued successfully, and note which queue they were sent to.
Review Email & Notification Delivery
Verify in the Mails and Notifications tabs that any critical emails or notifications were actually dispatched. If no entries appear, check your mail driver configuration or notification channel settings.
Use the Timeline for Performance Bottlenecks
When a run’s Duration spikes unexpectedly, start by examining the timeline’s longest phases (e.g., “Command Execution” within the scheduled task). Drill down into Queries or Outbound Requests to pinpoint high-latency operations.

By combining the high-level task summary, historical run list—with filtering—and per-run event timelines, Laritor’s Scheduled Task Details view empowers you to ensure that your scheduled work executes reliably, efficiently, and on time.