Concurrency Feature Enhancements

[Amirhf1]

Overview

We’ve improved Laravel 12's Concurrency feature by adding better error handling, support for timeouts, and expanding the test coverage.

Key Improvements

1. Enhanced Error Handling

Process Driver Updates

• More informative error messages: Now error messages include task keys and provide clearer descriptions.
• Better validation: We validate process output before parsing it.
• Exception validation: Ensures the exception class exists before trying to instantiate it.
• Handling empty output: We now account for processes that generate no output.
• Timeout support: You can now set a timeout for process execution.

Before:

// Generic error message
throw new Exception('Concurrent process failed with exit code [1]. Message: ...');

After:

// Detailed error message with task context
throw new Exception("Concurrent process [api_call] failed with exit code [1]. Error: Connection timeout");

SyncDriver Updates

• Task key context: Error messages now include task identifiers, making debugging easier.
• Exception chaining: We preserve the original exception stack trace for better context.

2. Timeout Support

We’ve added a timeout feature to ProcessDriver:

// Run tasks with a 30-second timeout
$results = Concurrency::driver('process')->run([
    'slow_task' => fn () => someSlowOperation(),
], 30);

3. Comprehensive Test Coverage

We’ve added 8 new test cases that cover:

• Timeout handling - Ensures tasks respect the timeout limit.
• Large data handling - Tests with payloads over 1MB.
• Context in error messages - Verifies task keys show up in error messages.
• Edge cases - Handles cases like empty task arrays.
• Single task execution - Verifies minimal use cases.
• Complex data structures - Tests for complex nested return types.
• Specific process error messages - More detailed failure reporting.
• Manager functionality - Verifies driver creation and singleton behavior.

4. Memory and Performance Optimizations

• Optimized error handling: Avoids unnecessary serialization during errors.
• Better support for large payloads: More memory-efficient processing for memory-intensive tasks.
• Faster JSON error detection: Immediately fails on malformed output to save time.

API Enhancements

New Method Signatures

// ProcessDriver with timeout support
public function run(Closure|array $tasks, int $timeout = null): array

// Improved error messages for all drivers
// Example Error: "Synchronous task [user_validation] failed: Invalid email format"

Backward Compatibility

• 100% compatible: Existing code continues to work as expected.
• Optional parameters: Timeout is optional, with a default of null.
• Consistent return types: No breaking changes to how return values are structured.

Usage Examples

Basic Usage (No Changes)

$results = Concurrency::run([
    fn () => fetchUserData($userId),
    fn () => fetchUserPosts($userId),
]);

Using Timeout

$results = Concurrency::driver('process')->run([
    'api_call' => fn () => Http::timeout(10)->get('/api/data'),
    'db_query' => fn () => DB::table('users')->get(),
], 30); // 30-second timeout for all tasks

Handling Errors

try {
    $results = Concurrency::run([
        'task_1' => fn () => riskyOperation(),
        'task_2' => fn () => anotherOperation(),
    ]);
} catch (Exception $e) {
    // Now the error message includes task context:
    // "Synchronous task [task_1] failed: Database connection lost"
    logger()->error($e->getMessage());
}

Processing Large Data

$results = Concurrency::run([
    'process_images' => fn () => processLargeImageBatch($images),
    'generate_report' => fn () => generateHeavyReport($data),
]);

Testing Improvements

New Test Categories

1. Edge Cases

   • Empty task arrays
   • Single task execution
   • Handling large payloads (1MB+)

2. Error Scenarios

   • Timeouts
   • Malformed JSON output
   • Missing exception classes
   • Empty process output

3. Data Handling

   • Complex nested structures
   • Objects and arrays
   • Large datasets

4. Driver Management

   • Singleton behavior
   • Driver switching
   • Configuration handling

Performance Impact

• No performance regression: All optimizations either maintain or improve speed.
• Memory-efficient: Optimized for handling large data without memory leaks.
• Quick error handling: Fast failure on malformed output saves processing time.
• Timeout efficiency: Prevents tasks from consuming resources after timing out.

Benefits

1. Improved Debugging: Task-specific error messages make it easier to debug.
2. Production Ready: Timeout support ensures tasks won’t run indefinitely.
3. Robust Error Handling: Comprehensive error checking helps avoid surprises.
4. Better Scalability: Handles larger tasks efficiently, making it suitable for complex systems.
5. Developer-Friendly: Clear and actionable error messages improve the developer experience.

This update strengthens Laravel’s Concurrency feature, ensuring it’s more reliable, robust, and ready for production, all while maintaining backward compatibility.