alexei.dolgolyov/maraphon-app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf(scraping): parallel HTTP fan-out, sequential DB persist (HIGH)

Browse Source 
The Pull*UseCase implementations issued one HTTP request at a time despite
Scraping:MaxConcurrentRequests=4. With 30–80 live events and ~1s per
fetch, a 5–10s live cadence target was unreachable; cycles overflowed
the configured interval.

* New Marathon.Application.Configuration.ScrapingThrottle bound from the
  shared Scraping:* section. Exposes only MaxConcurrentRequests so the
  Application layer doesn't pull in the Infrastructure-side ScrapingOptions.
* PullLiveOddsUseCase + PullUpcomingEventsUseCase split into two phases:
  - Phase 1 — Parallel.ForEachAsync over the event list with
    MaxDegreeOfParallelism = throttle.MaxConcurrentRequests. The scraper's
    Polly rate limiter still throttles to RequestsPerSecond underneath
    this fan-out, so spikes are smoothed before they hit the bookmaker.
  - Phase 2 — sequential foreach over the (Event, Snapshot) tuples
    captured in Phase 1, doing event upsert + snapshot insert. EF Core
    DbContext is not thread-safe so all DB writes stay on a single thread.
* InfrastructureModule binds ScrapingThrottle alongside AnomalyOptions.
* Failed snapshot scrapes in Phase 1 mean the event row is also NOT
  persisted in Phase 2 — previously we'd persist the row even when the
  snapshot scrape failed, leaving an orphan event with no odds. Updated
  the regression test accordingly.
* Test fixture exposes TestFixtures.Throttle(maxConcurrentRequests=1) for
  deterministic sequential test runs.
* One existing NSubstitute setup that chained Arg.Is<>() across two
  configurations was rewritten to use a single Arg.Any<>() with inline
  branching — chained matchers were leaking and returning wrong results.
This commit is contained in:
Admin
2026-05-09 15:27:06 +03:00
parent 66ae038243
commit 286b55986b
8 changed files with 177 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/Marathon.Application.Tests/UseCases/PullUpcomingEventsUseCaseTests.cs
+15 -8
View File
@@ -18,6 +18,7 @@ public sealed class PullUpcomingEventsUseCaseTests
private PullUpcomingEventsUseCase CreateSut() =>
new(_scraper, _eventRepo, _snapshotRepo,
TestFixtures.Throttle(),
NullLogger<PullUpcomingEventsUseCase>.Instance);
[Fact]
@@ -88,24 +89,30 @@ public sealed class PullUpcomingEventsUseCaseTests
var ev2 = TestFixtures.MakeEvent("22222222");
var events = new List<Event> { ev1, ev2 }.AsReadOnly();
_scraper.ScrapeUpcomingAsync(null, Arg.Any<CancellationToken>()).Returns(events);
_scraper.ScrapeUpcomingAsync(Arg.Any<SportCode?>(), Arg.Any<CancellationToken>()).Returns(events);
_eventRepo.GetAsync(Arg.Any<EventId>(), Arg.Any<CancellationToken>()).Returns((Event?)null);
// Inline routing of the throwing-vs-passing branch on event id, since chained
// Arg.Is<>() setups can leak matchers across NSubstitute invocations.
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == ev1.Id), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.ThrowsAsync(new HttpRequestException("site down"));
_scraper.ScrapeEventOddsAsync(
Arg.Is<Event>(e => e.Id == ev2.Id), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.Returns(TestFixtures.MakeSnapshot(ev2.Id));
Arg.Any<Event>(), OddsSource.PreMatch, Arg.Any<CancellationToken>())
.Returns<OddsSnapshot>(ci =>
{
var evArg = ci.Arg<Event>();
if (evArg.Id == ev1.Id)
throw new HttpRequestException("site down");
return TestFixtures.MakeSnapshot(evArg.Id);
});
var sut = CreateSut();
// Act — should not throw
var (processed, newEvents, snapshots) = await sut.ExecuteAsync(CancellationToken.None);
// Assert
// Assert: ev1's snapshot scrape failed in Phase 1, so it's not even
// attempted in Phase 2 — no orphan event row gets persisted.
processed.Should().Be(2);
newEvents.Should().Be(2);
newEvents.Should().Be(1, "ev1's snapshot failed so it was not persisted");
snapshots.Should().Be(1, "only ev2 snapshot succeeded");
}