LSP hangs on indexing

[CicerBro]

Verified on latest main

• I have confirmed this bug still occurs when built from the latest main branch.

PHPantom version / commit

Main

Installation method

Built from source

Operating system

macOS aarch64 (Apple Silicon)

Editor

VS Code

Bug description

The LSP hangs at indexing and is consuming 100% on all my cores in a certain Laravel project.

Is there any way I can see what exactly it's hanging on?

Steps to reproduce

N/A

Error output or panic trace

.phpantom.toml

Additional context

No response

[AJenbo]

Workspace diagnostics isn't actually indexing but scanning the project for errors. It should be usable while doing this as it happens in the background after indexing. I'm afraid that the only way to figure out what it's stuck on is to use debug tools or delete part of the repo until you hit on the part that is causing it to get stuck.

A third option is to pinpoint the commit that caused it to start hanging, then I might be able to figure out what about the change can cause it.

Does this also happen if you run phpantom_lsp analyze in the project root?

[itsmewes]

This has been happening to me as well. When I run phpantom_lsp analyze on the project root it eventually gets killed and doesn't complete. It did mention a specific file was slow, that file is a fairly small test file with a few mocks in it, so not sure if it's going down a rabbit hole with the mocks. If I clear out that test file and run again the analyze process still gets killed. When I use 0.9.0 it isn't an issue.

[AJenbo]

it only reports slow files when they finish so that won't be the one it's stuck on, but it could still be a good one to analyze for performance if you can share it.

its hard to say what's causing the hang / crash without a way to replicate it, I usually find the offending file by deleting half the repo, restore if it starts working and delete the other half, repeat until you find the offending file.

one note I believe it only reports slow files in debug builds which are generally ver slow so make sure you build with --release when your not needing to debug.

[itsmewes]

Thanks for the quick reply, I'll try debug some more and get back to you on that. I do build with --release so wouldn't have been a debug build.

[CicerBro]

Yeah, actually I see now it shows the files:

❯ ../phpantom_lsp/target/release/phpantom_lsp analyze
  935/939 [▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░]  99%
  ⚠ slow file (8.6s): tests/Feature/Tickets/TicketMergeTest.php
    scope=3.2s, fast=0.0s, slow=5.5s
  936/939 [▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░]  99%
  ⚠ slow file (30.5s): tests/Feature/Reporting/ReportingMetricsTest.php
    scope=0.0s, fast=0.0s, slow=30.5s
  937/939 [▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓░]  99%

And then just hangs there forever with all cores at 100% eating up RAM and Swap. This is a release build too. It never finished the last 2 files, whatever they are.

RAM 27.20 / 32.0 GB (85.0%)
SWAP 47.26 / 48.0 GB

  [build]
  rustflags = ["-C", "target-cpu=native"]
  [profile.release]
  lto = "fat"
  codegen-units = 1

This is the test file, although I think that message above means it already passed this file and moved on to others. The all cores is probably due to parallel work being done on similar tests (hundreds) taking forever.

<?php

use App\Domain\Tickets\Actions\MergeTicket;
use App\Domain\Tickets\Actions\UndoTicketMerge;
use App\Domain\Tickets\Queries\ContactAndTicketHistoryQuery;
use App\Enums\ComposerMode;
use App\Enums\MessageDeliveryStatus;
use App\Enums\MessageDirection;
use App\Enums\MessageKind;
use App\Enums\TeamRole;
use App\Enums\TicketActivityType;
use App\Enums\TicketStatus;
use App\Exceptions\TicketMergeConflictException;
use App\Models\Channel;
use App\Models\Contact;
use App\Models\Message;
use App\Models\MessageAttachment;
use App\Models\MessageRecipient;
use App\Models\OutboxMessage;
use App\Models\Tag;
use App\Models\Team;
use App\Models\Ticket;
use App\Models\TicketActivity;
use App\Models\TicketDraft;
use App\Models\TicketMerge;
use App\Models\User;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Str;

beforeEach(function () {
    $this->withoutVite();
    config()->set('scout.driver', 'collection');
    config()->set('scout.queue', false);
});

/**
 * @return array{team: Team, user: User, source: Ticket, target: Ticket}
 */
function ticketMergeFixture(
    TeamRole $role = TeamRole::Owner,
    bool $grantTargetChannel = true,
): array {
    $team = Team::factory()->create();
    $user = User::factory()->create();
    $team->memberships()->create([
        'user_id' => $user->id,
        'role' => $role,
    ]);
    $sourceChannel = Channel::factory()->for($team)->create();
    $targetChannel = Channel::factory()->for($team)->create();

    if ($role === TeamRole::Member) {
        $sourceChannel->directUsers()->attach($user, ['team_id' => $team->id]);

        if ($grantTargetChannel) {
            $targetChannel->directUsers()->attach($user, ['team_id' => $team->id]);
        }
    }

    $source = Ticket::factory()
        ->for($team)
        ->for($sourceChannel)
        ->for(Contact::factory()->for($team))
        ->create([
            'subject' => 'Duplicate source request',
            'status' => TicketStatus::Waiting,
            'waiting_until' => now()->addDay(),
            'last_activity_at' => now()->subHour(),
        ]);
    $target = Ticket::factory()
        ->for($team)
        ->for($targetChannel)
        ->for(Contact::factory()->for($team))
        ->create([
            'subject' => 'Canonical request',
            'last_activity_at' => now()->subMinutes(30),
        ]);

    return compact('team', 'user', 'source', 'target');
}

function mergeTickets(User $user, Ticket $source, Ticket $target): TicketMerge
{
    return app(MergeTicket::class)->handle(
        actor: $user,
        source: $source,
        target: $target,
        expectedSourceUpdatedAt: $source->fresh()->updated_at->toISOString(),
        expectedTargetUpdatedAt: $target->fresh()->updated_at->toISOString(),
        expectedSourceVersion: $source->fresh()->mutation_version,
        expectedTargetVersion: $target->fresh()->mutation_version,
        clientSubmissionId: (string) Str::uuid7(),
    );
}

test('merge creates immutable provenance and preserves every source-owned record', function () {
    Mail::fake();
    ['user' => $user, 'source' => $source, 'target' => $target] = ticketMergeFixture();
    $message = Message::factory()->for($source)->create([
        'team_id' => $source->team_id,
        'contact_id' => $source->contact_id,
        'channel_id' => $source->channel_id,
        'direction' => MessageDirection::Inbound,
        'kind' => MessageKind::CustomerMessage,
        'body_text' => 'Unique source searchable content',
    ]);
    $recipient = MessageRecipient::factory()->for($message)->create();
    $attachment = MessageAttachment::factory()->for($message)->create();
    $draft = TicketDraft::factory()->for($source)->for($user)->create([
        'mode' => ComposerMode::Reply,
        'body_text' => 'Unsent source draft',
        'body_html' => '<p>Unsent source draft</p>',
    ]);
    $tag = Tag::factory()->for($source->team)->create();
    $source->tags()->attach($tag, ['team_id' => $source->team_id]);
    $source->watchers()->attach($user, ['team_id' => $source->team_id]);
    $read = $source->reads()->create([
        'team_id' => $source->team_id,
        'user_id' => $user->id,
        'last_read_at' => now()->subMinute(),
    ]);

    $merge = mergeTickets($user, $source, $target);
    $source->refresh();
    $target->refresh();

    expect($source->merged_into_ticket_id)->toBe($target->id)
        ->and($source->merged_at)->not->toBeNull()
        ->and($source->status)->toBe(TicketStatus::Waiting)
        ->and($source->waiting_until)->not->toBeNull()
        ->and($message->fresh()->ticket_id)->toBe($source->id)
        ->and($recipient->fresh()->ticket_id)->toBe($source->id)
        ->and($attachment->fresh()->ticket_id)->toBe($source->id)
        ->and($draft->fresh()->ticket_id)->toBe($source->id)
        ->and($read->fresh()->ticket_id)->toBe($source->id)
        ->and($source->tags()->pluck('tags.id')->all())->toBe([$tag->id])
        ->and($source->watchers()->pluck('users.id')->all())->toBe([$user->id])
        ->and($target->mergedSources()->sole()->is($source))->toBeTrue()
        ->and($merge->provenance['strategy'])->toBe('tombstone-v1')
        ->and($merge->provenance['source']['message_public_ids'])->toBe([$message->public_id])
        ->and($merge->provenance['source']['message_recipient_public_ids'])->toBe([$recipient->public_id])
        ->and($merge->provenance['source']['message_attachment_public_ids'])->toBe([$attachment->public_id])
        ->and($merge->provenance['source']['drafts'][0]['public_id'])->toBe($draft->public_id)
        ->and($source->activities()->where('type', TicketActivityType::MergedInto)->count())->toBe(1)
        ->and($target->activities()->where('type', TicketActivityType::MergedFrom)->count())->toBe(1)
        ->and(OutboxMessage::query()->count())->toBe(0)
        ->and(fn () => $merge->update(['provenance' => []]))
        ->toThrow(LogicException::class)
        ->and(fn () => $merge->delete())
        ->toThrow(LogicException::class);

    Mail::assertNothingSent();
});

test('merge enforces tenant channel and stale request safety without leaking targets', function () {
    ['team' => $team, 'user' => $user, 'source' => $source, 'target' => $target] = ticketMergeFixture(
        TeamRole::Member,
        grantTargetChannel: false,
    );
    $sourceUpdatedAt = $source->updated_at->toISOString();
    $targetUpdatedAt = $target->updated_at->toISOString();
    $sourceVersion = $source->mutation_version;
    $targetVersion = $target->mutation_version;

    $this->actingAs($user)
        ->post(route('tickets.merges.store', [$team, $source]), [
            'target_ticket_public_id' => $target->public_id,
            'expected_source_updated_at' => $sourceUpdatedAt,
            'expected_target_updated_at' => $targetUpdatedAt,
            'expected_source_version' => $sourceVersion,
            'expected_target_version' => $targetVersion,
            'client_submission_id' => (string) Str::uuid7(),
        ])
        ->assertNotFound();

    $target->channel->directUsers()->attach($user, ['team_id' => $team->id]);
    $target->update(['subject' => 'Changed concurrently']);

    expect(fn () => app(MergeTicket::class)->handle(
        actor: $user,
        source: $source,
        target: $target,
        expectedSourceUpdatedAt: $sourceUpdatedAt,
        expectedTargetUpdatedAt: $targetUpdatedAt,
        expectedSourceVersion: $sourceVersion,
        expectedTargetVersion: $targetVersion,
        clientSubmissionId: (string) Str::uuid7(),
    ))->toThrow(TicketMergeConflictException::class);

    $foreignTeam = Team::factory()->create();
    $foreign = Ticket::factory()
        ->for($foreignTeam)
        ->for(Channel::factory()->for($foreignTeam))
        ->for(Contact::factory()->for($foreignTeam))
        ->create();

    expect(fn () => mergeTickets($user, $source, $source))
        ->toThrow(TicketMergeConflictException::class)
        ->and(fn () => mergeTickets($user, $source, $foreign))
        ->toThrow(TicketMergeConflictException::class);
});

test('merge rejects unsafe chains and pending delivery and retries idempotently', function () {
    ['user' => $user, 'source' => $source, 'target' => $target] = ticketMergeFixture();
    $submissionId = (string) Str::uuid7();
    $sourceUpdatedAt = $source->updated_at->toISOString();
    $targetUpdatedAt = $target->updated_at->toISOString();
    $sourceVersion = $source->mutation_version;
    $targetVersion = $target->mutation_version;
    $action = app(MergeTicket::class);
    $first = $action->handle(
        $user,
        $source,
        $target,
        $sourceUpdatedAt,
        $targetUpdatedAt,
        $sourceVersion,
        $targetVersion,
        $submissionId,
    );
    $retry = $action->handle(
        $user,
        $source,
        $target,
        $sourceUpdatedAt,
        $targetUpdatedAt,
        $sourceVersion,
        $targetVersion,
        $submissionId,
    );

    expect($retry->is($first))->toBeTrue()
        ->and(TicketMerge::query()->count())->toBe(1)
        ->and(TicketActivity::query()
            ->whereIn('type', [TicketActivityType::MergedInto, TicketActivityType::MergedFrom])
            ->count())->toBe(2);

    ['user' => $secondUser, 'source' => $secondSource, 'target' => $secondTarget] = ticketMergeFixture();
    Message::factory()->for($secondSource)->create([
        'team_id' => $secondSource->team_id,
        'contact_id' => $secondSource->contact_id,
        'channel_id' => $secondSource->channel_id,
        'delivery_status' => MessageDeliveryStatus::Queued,
    ]);

    expect(fn () => mergeTickets($secondUser, $secondSource, $secondTarget))
        ->toThrow(TicketMergeConflictException::class);
});

test('undo restores the source exactly and appends audit history without deleting provenance', function () {
    ['user' => $user, 'source' => $source, 'target' => $target] = ticketMergeFixture();
    $message = Message::factory()->for($source)->create([
        'team_id' => $source->team_id,
        'contact_id' => $source->contact_id,
        'channel_id' => $source->channel_id,
    ]);
    $draft = TicketDraft::factory()->for($source)->for($user)->create();
    $merge = mergeTickets($user, $source, $target);
    $submission = (string) Str::uuid7();

    $undone = app(UndoTicketMerge::class)->handle($user, $merge, $submission);
    $retry = app(UndoTicketMerge::class)->handle($user, $undone, $submission);
    $source->refresh();

    expect($source->merged_into_ticket_id)->toBeNull()
        ->and($source->merged_at)->toBeNull()
        ->and($source->status)->toBe(TicketStatus::Waiting)
        ->and($message->fresh()->ticket_id)->toBe($source->id)
        ->and($draft->fresh()->ticket_id)->toBe($source->id)
        ->and($retry->undone_at)->not->toBeNull()
        ->and($retry->undo_submission_id)->toBe($submission)
        ->and($retry->provenance)->toBe($merge->provenance)
        ->and(TicketActivity::query()
            ->where('type', TicketActivityType::MergeUndone)
            ->count())->toBe(2)
        ->and(TicketMerge::query()->count())->toBe(1);
});

test('undo safely refuses any post merge ticket activity or ownership change', function () {
    ['user' => $user, 'source' => $source, 'target' => $target] = ticketMergeFixture();
    $merge = mergeTickets($user, $source, $target);
    TicketActivity::factory()->for($target)->create([
        'type' => TicketActivityType::StatusChanged,
        'occurred_at' => now()->addSecond(),
    ]);

    expect(fn () => app(UndoTicketMerge::class)->handle(
        $user,
        $merge,
        (string) Str::uuid7(),
    ))->toThrow(TicketMergeConflictException::class, 'Ticket activity was recorded after the merge.');

    expect($source->fresh()->merged_into_ticket_id)->toBe($target->id)
        ->and($merge->fresh()->undone_at)->toBeNull();
});

test('merged source links redirect canonically while hidden targets remain non leaking', function () {
    ['team' => $team, 'user' => $user, 'source' => $source, 'target' => $target] = ticketMergeFixture(
        TeamRole::Member,
    );
    $message = Message::factory()->for($source)->create([
        'team_id' => $source->team_id,
        'contact_id' => $source->contact_id,
        'channel_id' => $source->channel_id,
    ]);
    mergeTickets($user, $source, $target);

    $this->actingAs($user)
        ->get(route('tickets.show', [$team, $source]))
        ->assertRedirect(route('tickets.show', [$team, $target]));
    $this->actingAs($user)
        ->get(route('tickets.messages.show', [$team, $source, $message]))
        ->assertRedirect(route('tickets.show', [
            'current_team' => $team,
            'ticket' => $target,
            'merged_message' => $message->public_id,
        ]));

    $target->channel->directUsers()->detach($user);

    $this->actingAs($user)
        ->get(route('tickets.show', [$team, $source]))
        ->assertNotFound();
});

test('merged sources disappear from views and contact counts while their thread remains on target', function () {
    ['team' => $team, 'user' => $user, 'source' => $source, 'target' => $target] = ticketMergeFixture();
    $source->update(['contact_id' => $target->contact_id]);
    $message = Message::factory()->for($source)->create([
        'team_id' => $source->team_id,
        'contact_id' => $source->contact_id,
        'channel_id' => $source->channel_id,
        'body_text' => 'Merged chronology marker',
    ]);
    mergeTickets($user, $source->fresh(), $target->fresh());

    $history = app(ContactAndTicketHistoryQuery::class)
        ->handle($user, $team, $target->public_id);
    $searchResults = Ticket::search('Merged chronology marker')->get();

    expect($history->contact->accessibleTicketCount)->toBe(1)
        ->and(Ticket::query()
            ->forTeam($team)
            ->whereNull('merged_into_ticket_id')
            ->pluck('public_id')
            ->all())->toBe([$target->public_id])
        ->and($source->fresh()->shouldBeSearchable())->toBeFalse()
        ->and($target->fresh()->toSearchableArray()['message_text'])
        ->toContain($message->body_text)
        ->and($searchResults->pluck('public_id')->all())
        ->toBe([$target->public_id]);
});

test('merged sources reject normal mutations and merge rollback is atomic', function () {
    ['team' => $team, 'user' => $user, 'source' => $source, 'target' => $target] = ticketMergeFixture();
    mergeTickets($user, $source, $target);

    $this->actingAs($user)
        ->patchJson(route('tickets.subject.update', [$team, $source]), [
            'subject' => 'Should not change',
            'expected_version' => $source->subject_version,
        ])
        ->assertForbidden();

    ['user' => $secondUser, 'source' => $secondSource, 'target' => $secondTarget] = ticketMergeFixture();
    TicketMerge::creating(function (): never {
        throw new RuntimeException('Simulated ledger failure');
    });

    expect(fn () => mergeTickets($secondUser, $secondSource, $secondTarget))
        ->toThrow(RuntimeException::class, 'Simulated ledger failure')
        ->and($secondSource->fresh()->merged_into_ticket_id)->toBeNull()
        ->and($secondTarget->fresh()->incomingMerge)->toBeNull()
        ->and(TicketActivity::query()
            ->whereIn('ticket_id', [$secondSource->id, $secondTarget->id])
            ->whereIn('type', [TicketActivityType::MergedInto, TicketActivityType::MergedFrom])
            ->count())->toBe(0);
});