Migrate from Redis by Upstash to Laravel Valkey

// config/cache.php, inside the 'stores' array...

'upstash-sessions' => [
    'driver' => 'redis',
    'connection' => 'upstash',
],

<?php

namespace App\Sessions;

use SessionHandlerInterface;

class DrainingSessionHandler implements SessionHandlerInterface
{
    public function __construct(
        protected SessionHandlerInterface $new,
        protected SessionHandlerInterface $old,
    ) {}

    public function read($id): string|false
    {
        return $this->new->read($id) ?: $this->old->read($id);
    }

    public function write($id, $data): bool
    {
        return $this->new->write($id, $data);
    }

    public function destroy($id): bool
    {
        $this->new->destroy($id);
        $this->old->destroy($id);

        return true;
    }

    public function open($path, $name): bool
    {
        return true;
    }

    public function close(): bool
    {
        return true;
    }

    public function gc($max_lifetime): int
    {
        return 0; // Expiry is handled by the cache TTLs...
    }
}

use App\Sessions\DrainingSessionHandler;
use Illuminate\Session\CacheBasedSessionHandler;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Session;

Session::extend('drain', function ($app) {
    $minutes = $app['config']['session.lifetime'];

    return new DrainingSessionHandler(
        new CacheBasedSessionHandler(Cache::store('redis'), $minutes),
        new CacheBasedSessionHandler(Cache::store('upstash-sessions'), $minutes),
    );
});

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\Redis\Connections\Connection;
use Illuminate\Support\Facades\Redis;

class MigrateCache extends Command
{
    protected $signature = 'cache:migrate
                            {--from=upstash : The source Redis connection}
                            {--to=valkey : The destination Redis connection}
                            {--chunk=1000 : Keys per SCAN iteration}
                            {--dry-run : Count keys by type without copying}';

    protected $description = 'Copy every key from one Redis connection to another';

    public function handle(): int
    {
        $source = Redis::connection($this->option('from'));
        $destination = $this->option('dry-run') ? null : Redis::connection($this->option('to'));

        $counts = [];
        $cursor = null;

        do {
            [$cursor, $keys] = $source->scan(
                $cursor, ['match' => '*', 'count' => (int) $this->option('chunk')]
            ) ?: [0, []];

            foreach ($keys as $key) {
                $type = $this->typeOf($source, $key);

                if ($destination && ! $this->copy($source, $destination, $key, $type)) {
                    $this->warn("Skipped [{$key}] of unsupported type [{$type}].");

                    continue;
                }

                $counts[$type] = ($counts[$type] ?? 0) + 1;
            }
        } while ((int) $cursor !== 0);

        $this->table(
            ['Type', $destination ? 'Copied' : 'Counted'],
            collect($counts)->map(fn ($count, $type) => [$type, $count])->values()
        );

        return static::SUCCESS;
    }

    protected function copy(Connection $source, Connection $destination, string $key, string $type): bool
    {
        $ttl = $source->pttl($key);

        if ($ttl === -2) {
            return true; // The key expired mid-scan...
        }

        $destination->del($key);

        $copied = match ($type) {
            'string' => $destination->set($key, $source->get($key)),
            'hash' => $destination->hmset($key, $source->hgetall($key)),
            'list' => $destination->rpush($key, ...$source->lrange($key, 0, -1)),
            'set' => $destination->sadd($key, ...$source->smembers($key)),
            'zset' => $destination->zadd($key, ...collect($source->zrange($key, 0, -1, true))
                ->flatMap(fn ($score, $member) => [$score, $member])->all()),
            default => false,
        };

        if ($copied !== false && $ttl > 0) {
            $destination->pexpire($key, $ttl);
        }

        return $copied !== false;
    }

    protected function typeOf(Connection $connection, string $key): string
    {
        $type = $connection->type($key);

        return match ($type) {
            \Redis::REDIS_STRING => 'string',
            \Redis::REDIS_SET => 'set',
            \Redis::REDIS_LIST => 'list',
            \Redis::REDIS_ZSET => 'zset',
            \Redis::REDIS_HASH => 'hash',
            \Redis::REDIS_STREAM => 'stream',
            default => is_string($type) ? strtolower($type) : 'unknown',
        };
    }
}

Read https://cloud.laravel.com/docs/knowledge-base/migrate-upstash-to-valkey and assess this
application's migration from Redis by Upstash to Laravel Valkey. Make no changes yet.

Inspect the Cloud environment's CACHE_STORE, SESSION_DRIVER, and QUEUE_CONNECTION settings; search
the repository for Redis usage, delayed job dispatches, and queue names; and check each queue's
backlog. Recommend a migration path, describe the cutover effects, and show the complete plan.

After I approve the plan, make the code changes on a branch and show me the diff before committing.
Stop and ask before swapping the cache, deploying, enabling maintenance mode, or deleting anything.
Before teardown, verify that the old queue is empty or that the source and destination key counts
match. Do not delete the Upstash cache until I confirm the application is healthy.