ahmido
81a07a41e4
Some checks failed
Main Confidence / confidence (push) Failing after 46s
## Summary - implement Spec 211 runtime trend reporting with bounded lane history, drift classification, hotspot trend output, and recalibration evidence handling - extend the repo-truth governance seams and workflow wrappers for comparable-bundle hydration, trend artifact publication, and contract-backed reporting - add the Spec 211 planning artifacts, data model, quickstart, tasks, and repository contract documents ## Validation - parsed `specs/211-runtime-trend-recalibration/contracts/test-runtime-trend-history.schema.json` - parsed `specs/211-runtime-trend-recalibration/contracts/test-runtime-trend.logical.openapi.yaml` - re-ran cross-artifact consistency analysis for the Spec 211 artifact set until no material findings remained - no application test suite was re-run as part of this final commit/push/PR step Co-authored-by: Ahmed Darrazi <ahmed.darrazi@live.de> Reviewed-on: #244
1878 lines
77 KiB
PHP
1878 lines
77 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace Tests\Support;
|
|
|
|
use SimpleXMLElement;
|
|
use ZipArchive;
|
|
|
|
final class TestLaneReport
|
|
{
|
|
/**
|
|
* @return array{junit: string, summary: string, budget: string, report: string, profile: string, trendHistory: string}
|
|
*/
|
|
public static function artifactPaths(string $laneId, ?string $artifactDirectory = null): array
|
|
{
|
|
$directory = trim($artifactDirectory ?? TestLaneManifest::artifactDirectory(), '/');
|
|
|
|
return [
|
|
'junit' => sprintf('%s/%s-latest.junit.xml', $directory, $laneId),
|
|
'summary' => sprintf('%s/%s-latest.summary.md', $directory, $laneId),
|
|
'budget' => sprintf('%s/%s-latest.budget.json', $directory, $laneId),
|
|
'report' => sprintf('%s/%s-latest.report.json', $directory, $laneId),
|
|
'profile' => sprintf('%s/%s-latest.profile.txt', $directory, $laneId),
|
|
'trendHistory' => sprintf('%s/%s-latest.trend-history.json', $directory, $laneId),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @return array<string, mixed>
|
|
*/
|
|
public static function artifactPublicationStatus(string $laneId, ?string $artifactDirectory = null): array
|
|
{
|
|
$artifactPaths = self::artifactPaths($laneId, $artifactDirectory);
|
|
$artifactFileMap = self::artifactFileMap($artifactPaths);
|
|
$artifactContract = TestLaneManifest::artifactPublicationContract($laneId);
|
|
$publishedArtifacts = [];
|
|
$missingRequiredArtifacts = [];
|
|
|
|
foreach (array_merge($artifactContract['requiredFiles'], $artifactContract['optionalFiles']) as $artifactFile) {
|
|
if (! array_key_exists($artifactFile, $artifactFileMap)) {
|
|
continue;
|
|
}
|
|
|
|
$relativePath = $artifactFileMap[$artifactFile];
|
|
$required = in_array($artifactFile, $artifactContract['requiredFiles'], true);
|
|
$exists = is_file(TestLaneManifest::absolutePath($relativePath));
|
|
|
|
$publishedArtifacts[] = [
|
|
'artifactType' => $artifactFile,
|
|
'relativePath' => $relativePath,
|
|
'required' => $required,
|
|
'exists' => $exists,
|
|
];
|
|
|
|
if ($required && ! $exists) {
|
|
$missingRequiredArtifacts[] = $artifactFile;
|
|
}
|
|
}
|
|
|
|
return [
|
|
'contractId' => $artifactContract['contractId'],
|
|
'laneId' => $laneId,
|
|
'sourceDirectory' => $artifactContract['sourceDirectory'],
|
|
'requiredFiles' => $artifactContract['requiredFiles'],
|
|
'optionalFiles' => $artifactContract['optionalFiles'],
|
|
'publishedArtifacts' => $publishedArtifacts,
|
|
'missingRequiredArtifacts' => $missingRequiredArtifacts,
|
|
'complete' => $missingRequiredArtifacts === [],
|
|
'primaryFailureClassId' => $missingRequiredArtifacts === [] ? null : 'artifact-publication-failure',
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed>|null $artifactPublicationStatus
|
|
* @param array<string, mixed>|null $budgetOutcome
|
|
*/
|
|
public static function classifyPrimaryFailure(
|
|
?int $exitCode,
|
|
?array $artifactPublicationStatus = null,
|
|
?array $budgetOutcome = null,
|
|
bool $entryPointResolved = true,
|
|
bool $workflowLaneMatched = true,
|
|
bool $infrastructureFailure = false,
|
|
): ?string {
|
|
if ($infrastructureFailure) {
|
|
return 'infrastructure-failure';
|
|
}
|
|
|
|
if (! $entryPointResolved || ! $workflowLaneMatched) {
|
|
return 'wrapper-failure';
|
|
}
|
|
|
|
if ($exitCode !== null && $exitCode !== 0) {
|
|
return 'test-failure';
|
|
}
|
|
|
|
if (is_array($artifactPublicationStatus) && ($artifactPublicationStatus['complete'] ?? true) !== true) {
|
|
return 'artifact-publication-failure';
|
|
}
|
|
|
|
if (is_array($budgetOutcome) && ($budgetOutcome['budgetStatus'] ?? 'within-budget') !== 'within-budget') {
|
|
return 'budget-breach';
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $report
|
|
* @param array<string, mixed>|null $budgetOutcome
|
|
* @param array<string, mixed>|null $artifactPublicationStatus
|
|
* @return array<string, mixed>
|
|
*/
|
|
public static function buildCiSummary(
|
|
array $report,
|
|
?int $exitCode = 0,
|
|
?array $budgetOutcome = null,
|
|
?array $artifactPublicationStatus = null,
|
|
bool $entryPointResolved = true,
|
|
bool $workflowLaneMatched = true,
|
|
bool $infrastructureFailure = false,
|
|
): array {
|
|
$artifactPublicationStatus ??= self::artifactPublicationStatus((string) $report['laneId']);
|
|
$budgetOutcome ??= is_array($report['ciBudgetEvaluation'] ?? null) ? $report['ciBudgetEvaluation'] : null;
|
|
$primaryFailureClassId = self::classifyPrimaryFailure(
|
|
exitCode: $exitCode,
|
|
artifactPublicationStatus: $artifactPublicationStatus,
|
|
budgetOutcome: $budgetOutcome,
|
|
entryPointResolved: $entryPointResolved,
|
|
workflowLaneMatched: $workflowLaneMatched,
|
|
infrastructureFailure: $infrastructureFailure,
|
|
);
|
|
$budgetStatus = (string) ($budgetOutcome['budgetStatus'] ?? $report['budgetStatus'] ?? 'within-budget');
|
|
$blockingStatus = match ($primaryFailureClassId) {
|
|
'test-failure', 'wrapper-failure', 'artifact-publication-failure', 'infrastructure-failure' => 'blocking',
|
|
'budget-breach' => (string) ($budgetOutcome['blockingStatus'] ?? 'non-blocking-warning'),
|
|
default => 'informational',
|
|
};
|
|
|
|
return [
|
|
'runId' => (string) (getenv('GITEA_RUN_ID') ?: getenv('GITHUB_RUN_ID') ?: sprintf('local-%s', $report['laneId'])),
|
|
'workflowId' => (string) ($report['ciContext']['workflowId'] ?? sprintf('local-%s', $report['laneId'])),
|
|
'laneId' => (string) $report['laneId'],
|
|
'testStatus' => $exitCode === 0 ? 'passed' : 'failed',
|
|
'artifactStatus' => ($artifactPublicationStatus['complete'] ?? false) ? 'complete' : 'incomplete',
|
|
'budgetStatus' => $budgetStatus,
|
|
'blockingStatus' => $blockingStatus,
|
|
'primaryFailureClassId' => $primaryFailureClassId,
|
|
'publishedArtifacts' => $artifactPublicationStatus['publishedArtifacts'],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @return array<string, mixed>
|
|
*/
|
|
public static function stageArtifacts(string $laneId, string $stagingDirectory, ?string $artifactDirectory = null): array
|
|
{
|
|
$artifactPaths = self::artifactPaths($laneId, $artifactDirectory);
|
|
$artifactFileMap = self::artifactFileMap($artifactPaths);
|
|
$artifactContract = TestLaneManifest::artifactPublicationContract($laneId);
|
|
$stagingRoot = self::stagingRootPath($stagingDirectory);
|
|
|
|
self::ensureDirectory($stagingRoot);
|
|
|
|
$stagedArtifacts = [];
|
|
$missingRequiredArtifacts = [];
|
|
|
|
foreach (array_merge($artifactContract['requiredFiles'], $artifactContract['optionalFiles']) as $artifactFile) {
|
|
if (! array_key_exists($artifactFile, $artifactFileMap)) {
|
|
continue;
|
|
}
|
|
|
|
$required = in_array($artifactFile, $artifactContract['requiredFiles'], true);
|
|
$sourceRelativePath = $artifactFileMap[$artifactFile];
|
|
$sourceAbsolutePath = TestLaneManifest::absolutePath($sourceRelativePath);
|
|
|
|
if (! is_file($sourceAbsolutePath)) {
|
|
if ($required) {
|
|
$missingRequiredArtifacts[] = $artifactFile;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
$stagedFileName = self::stagedArtifactName((string) $artifactContract['stagedNamePattern'], $laneId, $artifactFile);
|
|
$targetAbsolutePath = $stagingRoot.DIRECTORY_SEPARATOR.$stagedFileName;
|
|
|
|
copy($sourceAbsolutePath, $targetAbsolutePath);
|
|
|
|
$stagedArtifacts[] = [
|
|
'artifactType' => $artifactFile,
|
|
'relativePath' => str_starts_with($stagingDirectory, DIRECTORY_SEPARATOR)
|
|
? $targetAbsolutePath
|
|
: trim($stagingDirectory, '/').'/'.$stagedFileName,
|
|
'required' => $required,
|
|
];
|
|
}
|
|
|
|
return [
|
|
'laneId' => $laneId,
|
|
'stagedArtifacts' => $stagedArtifacts,
|
|
'complete' => $missingRequiredArtifacts === [],
|
|
'primaryFailureClassId' => $missingRequiredArtifacts === [] ? null : 'artifact-publication-failure',
|
|
'missingRequiredArtifacts' => $missingRequiredArtifacts,
|
|
'uploadGroupName' => $artifactContract['uploadGroupName'],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @return array<string, mixed>
|
|
*/
|
|
public static function hydrateTrendHistory(
|
|
string $laneId,
|
|
?string $historyFile = null,
|
|
?string $bundlePath = null,
|
|
?string $artifactDirectory = null,
|
|
): array {
|
|
$artifactPaths = self::artifactPaths($laneId, $artifactDirectory);
|
|
$targetPath = TestLaneManifest::absolutePath($artifactPaths['trendHistory']);
|
|
|
|
self::ensureDirectory(dirname($targetPath));
|
|
|
|
$resolvedHistoryFile = is_string($historyFile) && trim($historyFile) !== ''
|
|
? self::resolveInputPath($historyFile)
|
|
: null;
|
|
$resolvedBundlePath = is_string($bundlePath) && trim($bundlePath) !== ''
|
|
? self::resolveInputPath($bundlePath)
|
|
: null;
|
|
|
|
if (is_string($resolvedHistoryFile) && is_file($resolvedHistoryFile)) {
|
|
copy($resolvedHistoryFile, $targetPath);
|
|
|
|
return [
|
|
'laneId' => $laneId,
|
|
'targetPath' => $targetPath,
|
|
'hydrated' => true,
|
|
'sourceType' => 'history-file',
|
|
'sourcePath' => $resolvedHistoryFile,
|
|
];
|
|
}
|
|
|
|
if (is_string($resolvedBundlePath) && $resolvedBundlePath !== '') {
|
|
if (is_dir($resolvedBundlePath)) {
|
|
$bundleHistoryPath = self::findTrendHistoryInDirectory($laneId, $resolvedBundlePath);
|
|
|
|
if (is_string($bundleHistoryPath)) {
|
|
copy($bundleHistoryPath, $targetPath);
|
|
|
|
return [
|
|
'laneId' => $laneId,
|
|
'targetPath' => $targetPath,
|
|
'hydrated' => true,
|
|
'sourceType' => 'bundle-directory',
|
|
'sourcePath' => $bundleHistoryPath,
|
|
];
|
|
}
|
|
} elseif (is_file($resolvedBundlePath) && str_ends_with(strtolower($resolvedBundlePath), '.zip')) {
|
|
$zip = new ZipArchive();
|
|
|
|
if ($zip->open($resolvedBundlePath) === true) {
|
|
$entryName = self::findTrendHistoryInZip($laneId, $zip);
|
|
|
|
if (is_string($entryName)) {
|
|
$contents = $zip->getFromName($entryName);
|
|
$zip->close();
|
|
|
|
if (is_string($contents) && $contents !== '') {
|
|
file_put_contents($targetPath, $contents);
|
|
|
|
return [
|
|
'laneId' => $laneId,
|
|
'targetPath' => $targetPath,
|
|
'hydrated' => true,
|
|
'sourceType' => 'bundle-zip',
|
|
'sourcePath' => $resolvedBundlePath,
|
|
'sourceEntry' => $entryName,
|
|
];
|
|
}
|
|
}
|
|
|
|
$zip->close();
|
|
}
|
|
}
|
|
}
|
|
|
|
return [
|
|
'laneId' => $laneId,
|
|
'targetPath' => $targetPath,
|
|
'hydrated' => false,
|
|
'sourceType' => null,
|
|
'sourcePath' => $resolvedHistoryFile ?? $resolvedBundlePath,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @return array{slowestEntries: list<array<string, mixed>>, durationsByFile: array<string, float>}
|
|
*/
|
|
public static function parseJUnit(string $filePath, string $laneId): array
|
|
{
|
|
if (! is_file($filePath)) {
|
|
return [
|
|
'slowestEntries' => [],
|
|
'durationsByFile' => [],
|
|
];
|
|
}
|
|
|
|
$useInternalErrors = libxml_use_internal_errors(true);
|
|
$xml = simplexml_load_file($filePath);
|
|
libxml_clear_errors();
|
|
libxml_use_internal_errors($useInternalErrors);
|
|
|
|
if (! $xml instanceof SimpleXMLElement) {
|
|
return [
|
|
'slowestEntries' => [],
|
|
'durationsByFile' => [],
|
|
];
|
|
}
|
|
|
|
$slowestEntries = [];
|
|
$durationsByFile = [];
|
|
|
|
foreach ($xml->xpath('//testcase') ?: [] as $testcase) {
|
|
$rawSubject = trim((string) ($testcase['file'] ?? ''));
|
|
$subject = $rawSubject !== '' ? $rawSubject : trim((string) ($testcase['name'] ?? 'unknown-testcase'));
|
|
$duration = round((float) ($testcase['time'] ?? 0.0), 6);
|
|
$normalizedFile = explode('::', $subject)[0];
|
|
|
|
$slowestEntries[] = [
|
|
'label' => $subject,
|
|
'subject' => $subject,
|
|
'filePath' => $normalizedFile,
|
|
'durationSeconds' => $duration,
|
|
'wallClockSeconds' => $duration,
|
|
'laneId' => $laneId,
|
|
];
|
|
|
|
$durationsByFile[$normalizedFile] = round(($durationsByFile[$normalizedFile] ?? 0.0) + $duration, 6);
|
|
}
|
|
|
|
usort($slowestEntries, static fn (array $left, array $right): int => $right['wallClockSeconds'] <=> $left['wallClockSeconds']);
|
|
|
|
return [
|
|
'slowestEntries' => array_slice($slowestEntries, 0, 10),
|
|
'durationsByFile' => $durationsByFile,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $slowestEntries
|
|
* @param array<string, float> $durationsByFile
|
|
* @return array<string, mixed>
|
|
*/
|
|
public static function buildReport(
|
|
string $laneId,
|
|
float $wallClockSeconds,
|
|
array $slowestEntries,
|
|
array $durationsByFile,
|
|
?string $artifactDirectory = null,
|
|
?string $comparisonProfile = null,
|
|
?array $ciContext = null,
|
|
): array {
|
|
$lane = TestLaneManifest::lane($laneId);
|
|
$heavyGovernanceContract = $laneId === 'heavy-governance'
|
|
? TestLaneManifest::heavyGovernanceBudgetContract($wallClockSeconds)
|
|
: null;
|
|
|
|
if (is_array($heavyGovernanceContract)) {
|
|
$lane['budget']['thresholdSeconds'] = $heavyGovernanceContract['normalizedThresholdSeconds'];
|
|
$lane['budget']['lifecycleState'] = $heavyGovernanceContract['lifecycleState'];
|
|
}
|
|
|
|
$laneBudget = TestLaneBudget::fromArray($lane['budget']);
|
|
$laneBudgetEvaluation = $laneBudget->evaluate($wallClockSeconds);
|
|
$resolvedCiContext = array_filter($ciContext ?? TestLaneManifest::currentCiContext($laneId), static fn (mixed $value): bool => $value !== null);
|
|
$ciBudgetEvaluation = null;
|
|
|
|
if (is_string($resolvedCiContext['triggerClass'] ?? null) && $resolvedCiContext['triggerClass'] !== '') {
|
|
$ciBudgetEvaluation = TestLaneBudget::evaluateLaneForTrigger(
|
|
$laneId,
|
|
(string) $resolvedCiContext['triggerClass'],
|
|
$wallClockSeconds,
|
|
);
|
|
}
|
|
|
|
$artifactPaths = self::artifactPaths($laneId, $artifactDirectory);
|
|
$artifacts = [];
|
|
|
|
foreach ($lane['artifacts'] as $artifactMode) {
|
|
$relativePath = match ($artifactMode) {
|
|
'summary' => $artifactPaths['summary'],
|
|
'junit-xml' => $artifactPaths['junit'],
|
|
'profile-top' => $artifactPaths['profile'],
|
|
'budget-report' => $artifactPaths['budget'],
|
|
default => null,
|
|
};
|
|
|
|
if (! is_string($relativePath)) {
|
|
continue;
|
|
}
|
|
|
|
$artifacts[] = [
|
|
'artifactMode' => $artifactMode,
|
|
'relativePath' => $relativePath,
|
|
'machineReadable' => in_array($artifactMode, ['junit-xml', 'budget-report'], true),
|
|
];
|
|
}
|
|
|
|
$attribution = self::buildAttribution($durationsByFile);
|
|
$relevantBudgetTargets = self::relevantBudgetTargets(
|
|
$laneId,
|
|
$attribution['classificationTotals'],
|
|
$attribution['familyTotals'],
|
|
);
|
|
|
|
if (is_array($heavyGovernanceContract)) {
|
|
$relevantBudgetTargets = array_values(array_map(
|
|
static function (array $budgetTarget) use ($heavyGovernanceContract): array {
|
|
if (($budgetTarget['targetType'] ?? null) !== 'lane' || ($budgetTarget['targetId'] ?? null) !== 'heavy-governance') {
|
|
return $budgetTarget;
|
|
}
|
|
|
|
$budgetTarget['thresholdSeconds'] = $heavyGovernanceContract['normalizedThresholdSeconds'];
|
|
$budgetTarget['lifecycleState'] = $heavyGovernanceContract['lifecycleState'];
|
|
|
|
return $budgetTarget;
|
|
},
|
|
$relevantBudgetTargets,
|
|
));
|
|
}
|
|
|
|
$budgetEvaluations = TestLaneBudget::evaluateBudgetTargets(
|
|
$relevantBudgetTargets,
|
|
$wallClockSeconds,
|
|
$attribution['classificationTotals'],
|
|
$attribution['familyTotals'],
|
|
);
|
|
|
|
$enrichedSlowestEntries = array_values(array_map(
|
|
static function (array $entry) use ($attribution): array {
|
|
$filePath = (string) ($entry['filePath'] ?? '');
|
|
$familyId = $attribution['fileToFamily'][$filePath] ?? null;
|
|
$classificationId = $attribution['fileToClassification'][$filePath] ?? null;
|
|
|
|
return array_filter(array_merge($entry, [
|
|
'familyId' => $familyId,
|
|
'classificationId' => $classificationId,
|
|
]), static fn (mixed $value): bool => $value !== null);
|
|
},
|
|
$slowestEntries,
|
|
));
|
|
|
|
$heavyGovernanceContext = $laneId === 'heavy-governance'
|
|
? self::buildHeavyGovernanceContext(
|
|
budgetContract: $heavyGovernanceContract ?? TestLaneManifest::heavyGovernanceBudgetContract(),
|
|
wallClockSeconds: $wallClockSeconds,
|
|
artifactPaths: [
|
|
'summary' => $artifactPaths['summary'],
|
|
'budget' => $artifactPaths['budget'],
|
|
'report' => $artifactPaths['report'],
|
|
],
|
|
classificationAttribution: $attribution['classificationAttribution'],
|
|
familyAttribution: $attribution['familyAttribution'],
|
|
slowestEntries: $enrichedSlowestEntries,
|
|
)
|
|
: [];
|
|
|
|
$report = [
|
|
'laneId' => $laneId,
|
|
'artifactDirectory' => trim($artifactDirectory ?? TestLaneManifest::artifactDirectory(), '/'),
|
|
'finishedAt' => gmdate('c'),
|
|
'wallClockSeconds' => round($wallClockSeconds, 6),
|
|
'budgetThresholdSeconds' => $laneBudget->thresholdSeconds,
|
|
'budgetBaselineSource' => $laneBudget->baselineSource,
|
|
'budgetEnforcement' => $laneBudget->enforcement,
|
|
'budgetLifecycleState' => $laneBudget->lifecycleState,
|
|
'budgetStatus' => $laneBudgetEvaluation['budgetStatus'],
|
|
'slowestEntries' => $enrichedSlowestEntries,
|
|
'classificationAttribution' => $attribution['classificationAttribution'],
|
|
'familyAttribution' => $attribution['familyAttribution'],
|
|
'budgetEvaluations' => $budgetEvaluations,
|
|
'familyBudgetEvaluations' => array_values(array_filter(
|
|
$budgetEvaluations,
|
|
static fn (array $evaluation): bool => ($evaluation['targetType'] ?? null) === 'family',
|
|
)),
|
|
'artifacts' => $artifacts,
|
|
'artifactPublicationContract' => TestLaneManifest::artifactPublicationContract($laneId),
|
|
'knownWorkflowProfiles' => array_values(array_map(
|
|
static fn (array $workflowProfile): string => (string) $workflowProfile['workflowId'],
|
|
TestLaneManifest::workflowProfilesForLane($laneId),
|
|
)),
|
|
'failureClasses' => TestLaneManifest::failureClasses(),
|
|
];
|
|
|
|
if ($heavyGovernanceContext !== []) {
|
|
$report = array_merge($report, $heavyGovernanceContext);
|
|
}
|
|
|
|
if ($laneBudget->baselineDeltaTargetPercent !== null) {
|
|
$report['baselineDeltaTargetPercent'] = $laneBudget->baselineDeltaTargetPercent;
|
|
}
|
|
|
|
$comparison = self::buildSharedFixtureSlimmingComparison($laneId, $wallClockSeconds, $comparisonProfile);
|
|
|
|
if ($comparison !== null) {
|
|
$report['sharedFixtureSlimmingComparison'] = $comparison;
|
|
}
|
|
|
|
if ($resolvedCiContext !== []) {
|
|
$report['ciContext'] = $resolvedCiContext;
|
|
}
|
|
|
|
if ($ciBudgetEvaluation !== null) {
|
|
$report['ciBudgetEvaluation'] = $ciBudgetEvaluation;
|
|
}
|
|
|
|
$trendHistoryArtifact = self::buildTrendHistoryArtifact($report, $artifactPaths);
|
|
$report['trendHistoryArtifact'] = $trendHistoryArtifact;
|
|
$report['trendCurrentAssessment'] = $trendHistoryArtifact['currentAssessment'];
|
|
$report['trendHotspotSnapshot'] = $trendHistoryArtifact['hotspotSnapshot'] ?? null;
|
|
$report['trendRecalibrationDecisions'] = $trendHistoryArtifact['recalibrationDecisions'] ?? [];
|
|
$report['trendWarnings'] = $trendHistoryArtifact['warnings'] ?? [];
|
|
|
|
return $report;
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $report
|
|
* @return array{summary: string, budget: string, report: string, profile: string, trendHistory: string}
|
|
*/
|
|
public static function writeArtifacts(
|
|
string $laneId,
|
|
array $report,
|
|
?string $profileOutput = null,
|
|
?string $artifactDirectory = null,
|
|
?int $exitCode = 0,
|
|
): array {
|
|
$artifactPaths = self::artifactPaths($laneId, $artifactDirectory);
|
|
|
|
self::ensureDirectory(dirname(TestLaneManifest::absolutePath($artifactPaths['summary'])));
|
|
|
|
file_put_contents(
|
|
TestLaneManifest::absolutePath($artifactPaths['summary']),
|
|
self::buildSummaryMarkdown($report),
|
|
);
|
|
|
|
if (is_string($profileOutput) && trim($profileOutput) !== '') {
|
|
file_put_contents(TestLaneManifest::absolutePath($artifactPaths['profile']), $profileOutput);
|
|
}
|
|
|
|
file_put_contents(
|
|
TestLaneManifest::absolutePath($artifactPaths['budget']),
|
|
json_encode(self::budgetPayload($report), JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR),
|
|
);
|
|
|
|
file_put_contents(
|
|
TestLaneManifest::absolutePath($artifactPaths['report']),
|
|
json_encode($report, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR),
|
|
);
|
|
|
|
file_put_contents(
|
|
TestLaneManifest::absolutePath($artifactPaths['trendHistory']),
|
|
json_encode($report['trendHistoryArtifact'] ?? [], JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR),
|
|
);
|
|
|
|
$report['artifactPublication'] = self::artifactPublicationStatus($laneId, $artifactDirectory);
|
|
$report['ciSummary'] = self::buildCiSummary(
|
|
report: $report,
|
|
exitCode: $exitCode,
|
|
budgetOutcome: is_array($report['ciBudgetEvaluation'] ?? null) ? $report['ciBudgetEvaluation'] : null,
|
|
artifactPublicationStatus: $report['artifactPublication'],
|
|
entryPointResolved: (bool) ($report['ciContext']['entryPointResolved'] ?? true),
|
|
workflowLaneMatched: (bool) ($report['ciContext']['workflowLaneMatched'] ?? true),
|
|
);
|
|
|
|
file_put_contents(
|
|
TestLaneManifest::absolutePath($artifactPaths['summary']),
|
|
self::buildSummaryMarkdown($report),
|
|
);
|
|
|
|
file_put_contents(
|
|
TestLaneManifest::absolutePath($artifactPaths['budget']),
|
|
json_encode(self::budgetPayload($report), JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR),
|
|
);
|
|
|
|
file_put_contents(
|
|
TestLaneManifest::absolutePath($artifactPaths['report']),
|
|
json_encode($report, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR),
|
|
);
|
|
|
|
return $artifactPaths;
|
|
}
|
|
|
|
/**
|
|
* @return array<string, mixed>
|
|
*/
|
|
public static function finalizeLane(
|
|
string $laneId,
|
|
float $wallClockSeconds,
|
|
string $capturedOutput = '',
|
|
?string $comparisonProfile = null,
|
|
?int $exitCode = 0,
|
|
): array {
|
|
$artifactPaths = self::artifactPaths($laneId);
|
|
$parsed = self::parseJUnit(TestLaneManifest::absolutePath($artifactPaths['junit']), $laneId);
|
|
$ciContext = TestLaneManifest::currentCiContext($laneId);
|
|
$report = self::buildReport(
|
|
laneId: $laneId,
|
|
wallClockSeconds: $wallClockSeconds,
|
|
slowestEntries: $parsed['slowestEntries'],
|
|
durationsByFile: $parsed['durationsByFile'],
|
|
comparisonProfile: $comparisonProfile,
|
|
ciContext: $ciContext,
|
|
);
|
|
|
|
self::writeArtifacts($laneId, $report, $capturedOutput, exitCode: $exitCode);
|
|
|
|
return $report;
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $report
|
|
*/
|
|
private static function buildSummaryMarkdown(array $report): string
|
|
{
|
|
$lines = [
|
|
'# Test Lane Summary',
|
|
'',
|
|
sprintf('- Lane: %s', $report['laneId']),
|
|
sprintf('- Finished: %s', $report['finishedAt']),
|
|
sprintf('- Wall clock: %.2f seconds', (float) $report['wallClockSeconds']),
|
|
sprintf('- Budget: %d seconds (%s)', (int) $report['budgetThresholdSeconds'], $report['budgetStatus']),
|
|
];
|
|
$trendHistory = is_array($report['trendHistoryArtifact'] ?? null)
|
|
? $report['trendHistoryArtifact']
|
|
: null;
|
|
$trendAssessment = is_array($report['trendCurrentAssessment'] ?? null)
|
|
? $report['trendCurrentAssessment']
|
|
: ($trendHistory['currentAssessment'] ?? null);
|
|
$currentTrendRecord = is_array($trendHistory['history'][0] ?? null)
|
|
? $trendHistory['history'][0]
|
|
: null;
|
|
$previousTrendRecord = is_array($trendHistory['history'][1] ?? null)
|
|
? $trendHistory['history'][1]
|
|
: null;
|
|
|
|
if (isset($report['ciSummary']) && is_array($report['ciSummary'])) {
|
|
$lines[] = sprintf(
|
|
'- CI outcome: %s / %s',
|
|
(string) $report['ciSummary']['testStatus'],
|
|
(string) $report['ciSummary']['blockingStatus'],
|
|
);
|
|
|
|
if (is_string($report['ciSummary']['primaryFailureClassId'] ?? null)) {
|
|
$lines[] = sprintf('- Primary failure class: %s', (string) $report['ciSummary']['primaryFailureClassId']);
|
|
}
|
|
}
|
|
|
|
if (($report['laneId'] ?? null) === 'heavy-governance' && isset($report['budgetContract']) && is_array($report['budgetContract'])) {
|
|
$lines[] = sprintf(
|
|
'- Budget contract: %.0f seconds (%s)',
|
|
(float) $report['budgetContract']['normalizedThresholdSeconds'],
|
|
(string) ($report['budgetOutcome']['decisionStatus'] ?? $report['budgetContract']['decisionStatus'] ?? 'pending'),
|
|
);
|
|
$lines[] = sprintf(
|
|
'- Legacy drift signal: %.0f seconds (pre-normalization evidence)',
|
|
(float) $report['budgetContract']['evaluationThresholdSeconds'],
|
|
);
|
|
|
|
if (isset($report['budgetOutcome']['deltaSeconds'], $report['budgetOutcome']['deltaPercent'])) {
|
|
$lines[] = sprintf(
|
|
'- Baseline delta: %+0.2f seconds (%+0.2f%%)',
|
|
(float) $report['budgetOutcome']['deltaSeconds'],
|
|
(float) $report['budgetOutcome']['deltaPercent'],
|
|
);
|
|
}
|
|
|
|
if (isset($report['inventoryCoverage']) && is_array($report['inventoryCoverage'])) {
|
|
$lines[] = sprintf(
|
|
'- Inventory coverage: %.2f%% across %d required families (%s)',
|
|
(float) $report['inventoryCoverage']['coveredRuntimePercent'],
|
|
(int) $report['inventoryCoverage']['requiredFamilyCount'],
|
|
(bool) $report['inventoryCoverage']['meetsInclusionRule'] ? 'meets inclusion rule' : 'missing required families',
|
|
);
|
|
}
|
|
}
|
|
|
|
if (isset($report['sharedFixtureSlimmingComparison']) && is_array($report['sharedFixtureSlimmingComparison'])) {
|
|
$comparison = $report['sharedFixtureSlimmingComparison'];
|
|
|
|
$lines[] = sprintf(
|
|
'- Shared fixture slimming baseline: %.2f seconds (%s, %+0.2f%%)',
|
|
(float) $comparison['baselineSeconds'],
|
|
(string) $comparison['status'],
|
|
(float) $comparison['deltaPercent'],
|
|
);
|
|
}
|
|
|
|
$lines[] = '';
|
|
$lines[] = '## Lane trend';
|
|
|
|
if (is_array($trendAssessment)) {
|
|
$previousRuntime = is_array($previousTrendRecord)
|
|
? sprintf('%.2fs', (float) ($previousTrendRecord['wallClockSeconds'] ?? 0.0))
|
|
: 'n/a';
|
|
$baselineRuntime = isset($currentTrendRecord['baselineSeconds']) && $currentTrendRecord['baselineSeconds'] !== null
|
|
? sprintf('%.2fs', (float) $currentTrendRecord['baselineSeconds'])
|
|
: 'n/a';
|
|
|
|
$lines[] = sprintf(
|
|
'- Window: current %.2fs | previous %s | baseline %s | budget %.2fs',
|
|
(float) $report['wallClockSeconds'],
|
|
$previousRuntime,
|
|
$baselineRuntime,
|
|
(float) $report['budgetThresholdSeconds'],
|
|
);
|
|
$lines[] = sprintf('- Health class: %s', (string) $trendAssessment['healthClass']);
|
|
$lines[] = sprintf('- Window status: %s', (string) $trendAssessment['windowStatus']);
|
|
$lines[] = sprintf('- Recalibration recommendation: %s', (string) $trendAssessment['recalibrationRecommendation']);
|
|
$lines[] = sprintf('- Budget headroom: %.2fs', (float) $trendAssessment['budgetHeadroomSeconds']);
|
|
$lines[] = sprintf('- Summary: %s', (string) $trendAssessment['summaryLine']);
|
|
|
|
if (array_key_exists('deltaToPreviousSeconds', $trendAssessment) && $trendAssessment['deltaToPreviousSeconds'] !== null) {
|
|
$lines[] = sprintf('- Delta to previous: %+0.2fs', (float) $trendAssessment['deltaToPreviousSeconds']);
|
|
}
|
|
|
|
if (array_key_exists('deltaToBaselineSeconds', $trendAssessment) && $trendAssessment['deltaToBaselineSeconds'] !== null) {
|
|
$lines[] = sprintf('- Delta to baseline: %+0.2fs', (float) $trendAssessment['deltaToBaselineSeconds']);
|
|
}
|
|
} else {
|
|
$lines[] = '- Trend assessment unavailable.';
|
|
}
|
|
|
|
$hotspotSnapshot = is_array($report['trendHotspotSnapshot'] ?? null)
|
|
? $report['trendHotspotSnapshot']
|
|
: ($trendHistory['hotspotSnapshot'] ?? null);
|
|
|
|
if (is_array($hotspotSnapshot)) {
|
|
$lines[] = sprintf('- Hotspot evidence: %s', (string) $hotspotSnapshot['evidenceAvailability']);
|
|
|
|
foreach (array_slice($hotspotSnapshot['familyDeltas'] ?? [], 0, 3) as $delta) {
|
|
$lines[] = sprintf(
|
|
'- Family delta: %s %+0.2fs',
|
|
(string) $delta['name'],
|
|
(float) $delta['deltaSeconds'],
|
|
);
|
|
}
|
|
}
|
|
|
|
foreach ($report['trendRecalibrationDecisions'] ?? [] as $decision) {
|
|
$lines[] = sprintf(
|
|
'- Recalibration: %s %s (%s)',
|
|
(string) $decision['targetType'],
|
|
(string) $decision['decisionStatus'],
|
|
(string) $decision['rationaleCode'],
|
|
);
|
|
}
|
|
|
|
foreach ($report['trendWarnings'] ?? [] as $warning) {
|
|
$lines[] = sprintf('- Warning: %s', $warning);
|
|
}
|
|
|
|
$lines[] = '';
|
|
$lines[] = '## Slowest entries';
|
|
|
|
foreach ($report['slowestEntries'] as $entry) {
|
|
$label = (string) ($entry['label'] ?? $entry['subject'] ?? 'unknown');
|
|
$lines[] = sprintf('- %s (%.2fs)', $label, (float) ($entry['wallClockSeconds'] ?? $entry['durationSeconds'] ?? 0.0));
|
|
}
|
|
|
|
if (($report['classificationAttribution'] ?? []) !== []) {
|
|
$lines[] = '';
|
|
$lines[] = '## Classification attribution';
|
|
|
|
foreach ($report['classificationAttribution'] as $entry) {
|
|
$lines[] = sprintf('- %s (%.2fs)', $entry['classificationId'], (float) $entry['totalWallClockSeconds']);
|
|
}
|
|
}
|
|
|
|
if (($report['familyAttribution'] ?? []) !== []) {
|
|
$lines[] = '';
|
|
$lines[] = '## Family attribution';
|
|
|
|
foreach ($report['familyAttribution'] as $entry) {
|
|
$lines[] = sprintf('- %s [%s] (%.2fs)', $entry['familyId'], $entry['classificationId'], (float) $entry['totalWallClockSeconds']);
|
|
}
|
|
}
|
|
|
|
return implode(PHP_EOL, $lines).PHP_EOL;
|
|
}
|
|
|
|
/**
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function buildAttribution(array $durationsByFile): array
|
|
{
|
|
$classificationTotals = [];
|
|
$familyTotals = [];
|
|
$classificationHotspots = [];
|
|
$familyHotspots = [];
|
|
$fileToClassification = [];
|
|
$fileToFamily = [];
|
|
|
|
foreach ($durationsByFile as $filePath => $duration) {
|
|
$family = TestLaneManifest::familyForFile($filePath);
|
|
$mixedResolution = TestLaneManifest::mixedFileResolution($filePath);
|
|
$classificationId = $mixedResolution['primaryClassificationId'] ?? ($family['classificationId'] ?? null);
|
|
|
|
if (! is_string($classificationId) || $classificationId === '') {
|
|
continue;
|
|
}
|
|
|
|
$classificationTotals[$classificationId] = round(($classificationTotals[$classificationId] ?? 0.0) + $duration, 6);
|
|
$classificationHotspots[$classificationId][] = $filePath;
|
|
$fileToClassification[$filePath] = $classificationId;
|
|
|
|
if (is_array($family)) {
|
|
$familyId = (string) $family['familyId'];
|
|
$familyTotals[$familyId] = round(($familyTotals[$familyId] ?? 0.0) + $duration, 6);
|
|
$familyHotspots[$familyId]['classificationId'] = $family['classificationId'];
|
|
$familyHotspots[$familyId]['hotspotFiles'][] = $filePath;
|
|
$fileToFamily[$filePath] = $familyId;
|
|
}
|
|
}
|
|
|
|
$classificationAttribution = array_values(array_map(
|
|
static fn (string $classificationId, float $total): array => [
|
|
'classificationId' => $classificationId,
|
|
'totalWallClockSeconds' => $total,
|
|
'hotspotFiles' => array_values(array_unique($classificationHotspots[$classificationId] ?? [])),
|
|
],
|
|
array_keys($classificationTotals),
|
|
$classificationTotals,
|
|
));
|
|
|
|
usort($classificationAttribution, static fn (array $left, array $right): int => $right['totalWallClockSeconds'] <=> $left['totalWallClockSeconds']);
|
|
|
|
$familyAttribution = array_values(array_map(
|
|
static function (string $familyId, float $total) use ($familyHotspots): array {
|
|
return [
|
|
'familyId' => $familyId,
|
|
'classificationId' => $familyHotspots[$familyId]['classificationId'],
|
|
'totalWallClockSeconds' => $total,
|
|
'hotspotFiles' => array_values(array_unique($familyHotspots[$familyId]['hotspotFiles'] ?? [])),
|
|
];
|
|
},
|
|
array_keys($familyTotals),
|
|
$familyTotals,
|
|
));
|
|
|
|
usort($familyAttribution, static fn (array $left, array $right): int => $right['totalWallClockSeconds'] <=> $left['totalWallClockSeconds']);
|
|
|
|
return [
|
|
'classificationTotals' => $classificationTotals,
|
|
'familyTotals' => $familyTotals,
|
|
'classificationAttribution' => $classificationAttribution,
|
|
'familyAttribution' => $familyAttribution,
|
|
'fileToClassification' => $fileToClassification,
|
|
'fileToFamily' => $fileToFamily,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, float> $classificationTotals
|
|
* @param array<string, float> $familyTotals
|
|
* @return list<array<string, mixed>>
|
|
*/
|
|
private static function relevantBudgetTargets(
|
|
string $laneId,
|
|
array $classificationTotals,
|
|
array $familyTotals,
|
|
): array {
|
|
return array_values(array_filter(
|
|
TestLaneManifest::budgetTargets(),
|
|
static function (array $budgetTarget) use ($laneId, $classificationTotals, $familyTotals): bool {
|
|
$targetType = (string) ($budgetTarget['targetType'] ?? '');
|
|
$targetId = (string) ($budgetTarget['targetId'] ?? '');
|
|
|
|
return match ($targetType) {
|
|
'lane' => $targetId === $laneId,
|
|
'classification' => array_key_exists($targetId, $classificationTotals),
|
|
'family' => array_key_exists($targetId, $familyTotals),
|
|
default => false,
|
|
};
|
|
},
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @return array<string, float|int|string>|null
|
|
*/
|
|
private static function buildSharedFixtureSlimmingComparison(
|
|
string $laneId,
|
|
float $wallClockSeconds,
|
|
?string $comparisonProfile,
|
|
): ?array {
|
|
if ($comparisonProfile !== 'shared-test-fixture-slimming') {
|
|
return null;
|
|
}
|
|
|
|
$baseline = TestLaneManifest::comparisonBaseline($comparisonProfile, $laneId);
|
|
|
|
if (! is_array($baseline)) {
|
|
return null;
|
|
}
|
|
|
|
$baselineSeconds = (float) $baseline['wallClockSeconds'];
|
|
$deltaSeconds = round($wallClockSeconds - $baselineSeconds, 6);
|
|
$deltaPercent = $baselineSeconds > 0
|
|
? round(($deltaSeconds / $baselineSeconds) * 100, 6)
|
|
: 0.0;
|
|
$targetImprovementPercent = (int) ($baseline['targetImprovementPercent'] ?? 10);
|
|
$maxRegressionPercent = (int) ($baseline['maxRegressionPercent'] ?? 5);
|
|
|
|
$status = 'stable';
|
|
|
|
if ($deltaPercent <= -$targetImprovementPercent) {
|
|
$status = 'improved';
|
|
} elseif ($deltaPercent > $maxRegressionPercent) {
|
|
$status = 'regressed';
|
|
}
|
|
|
|
return [
|
|
'comparisonProfile' => $comparisonProfile,
|
|
'baselineFinishedAt' => (string) $baseline['finishedAt'],
|
|
'baselineSeconds' => $baselineSeconds,
|
|
'deltaSeconds' => $deltaSeconds,
|
|
'deltaPercent' => $deltaPercent,
|
|
'targetImprovementPercent' => $targetImprovementPercent,
|
|
'maxRegressionPercent' => $maxRegressionPercent,
|
|
'status' => $status,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $classificationAttribution
|
|
* @param list<array<string, mixed>> $familyAttribution
|
|
* @param list<array<string, mixed>> $slowestEntries
|
|
* @param array{summary: string, budget: string, report: string} $artifactPaths
|
|
* @param array<string, mixed> $budgetContract
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function buildHeavyGovernanceContext(
|
|
array $budgetContract,
|
|
float $wallClockSeconds,
|
|
array $artifactPaths,
|
|
array $classificationAttribution,
|
|
array $familyAttribution,
|
|
array $slowestEntries,
|
|
): array {
|
|
$inventory = TestLaneManifest::heavyGovernanceHotspotInventory();
|
|
$inventoryCoverage = self::buildHeavyGovernanceInventoryCoverage($familyAttribution, $inventory, $wallClockSeconds);
|
|
$budgetSnapshots = [
|
|
TestLaneManifest::heavyGovernanceBudgetSnapshots()[0],
|
|
[
|
|
'snapshotId' => 'post-slimming',
|
|
'capturedAt' => gmdate('c'),
|
|
'wallClockSeconds' => round($wallClockSeconds, 6),
|
|
'classificationTotals' => array_map(
|
|
static fn (array $entry): array => [
|
|
'classificationId' => (string) $entry['classificationId'],
|
|
'totalWallClockSeconds' => round((float) $entry['totalWallClockSeconds'], 6),
|
|
],
|
|
$classificationAttribution,
|
|
),
|
|
'familyTotals' => array_map(
|
|
static fn (array $entry): array => [
|
|
'familyId' => (string) $entry['familyId'],
|
|
'totalWallClockSeconds' => round((float) $entry['totalWallClockSeconds'], 6),
|
|
],
|
|
$familyAttribution,
|
|
),
|
|
'slowestEntries' => array_map(
|
|
static fn (array $entry): array => [
|
|
'label' => (string) $entry['label'],
|
|
'wallClockSeconds' => round((float) ($entry['wallClockSeconds'] ?? 0.0), 6),
|
|
],
|
|
$slowestEntries,
|
|
),
|
|
'artifactPaths' => $artifactPaths,
|
|
'budgetStatus' => (string) TestLaneBudget::evaluateGovernanceContract($budgetContract, $wallClockSeconds)['budgetStatus'],
|
|
],
|
|
];
|
|
$remainingOpenFamilies = array_values(array_map(
|
|
static fn (array $record): string => $record['familyId'],
|
|
array_filter(
|
|
$inventory,
|
|
static fn (array $record): bool => in_array($record['status'], ['retained', 'follow-up'], true),
|
|
),
|
|
));
|
|
$stabilizedFamilies = array_values(array_map(
|
|
static fn (array $record): string => $record['familyId'],
|
|
array_filter(
|
|
$inventory,
|
|
static fn (array $record): bool => $record['status'] === 'slimmed',
|
|
),
|
|
));
|
|
$followUpDebt = array_values(array_map(
|
|
static fn (array $decision): string => $decision['familyId'],
|
|
array_filter(
|
|
TestLaneManifest::heavyGovernanceSlimmingDecisions(),
|
|
static fn (array $decision): bool => in_array($decision['decisionType'], ['retain', 'follow-up'], true),
|
|
),
|
|
));
|
|
$budgetOutcome = TestLaneBudget::buildOutcomeRecord(
|
|
contract: $budgetContract,
|
|
baselineSnapshot: $budgetSnapshots[0],
|
|
currentSnapshot: $budgetSnapshots[1],
|
|
remainingOpenFamilies: $remainingOpenFamilies,
|
|
justification: $budgetContract['decisionStatus'] === 'recalibrated'
|
|
? sprintf(
|
|
'The primary workflow-heavy hotspots were slimmed, but the lane still retains intentional surface-guard depth and the workspace settings residual helper cost, so the authoritative threshold is now %.0fs.',
|
|
$budgetContract['normalizedThresholdSeconds'],
|
|
)
|
|
: 'The primary workflow-heavy hotspots slimmed enough duplicated work for the heavy-governance lane to recover within 300 seconds.',
|
|
followUpDebt: $followUpDebt,
|
|
);
|
|
|
|
return [
|
|
'budgetContract' => $budgetContract,
|
|
'hotspotInventory' => $inventory,
|
|
'decompositionRecords' => TestLaneManifest::heavyGovernanceDecompositionRecords(),
|
|
'slimmingDecisions' => TestLaneManifest::heavyGovernanceSlimmingDecisions(),
|
|
'authorGuidance' => TestLaneManifest::heavyGovernanceAuthorGuidance(),
|
|
'inventoryCoverage' => $inventoryCoverage,
|
|
'budgetSnapshots' => $budgetSnapshots,
|
|
'budgetOutcome' => $budgetOutcome,
|
|
'remainingOpenFamilies' => $remainingOpenFamilies,
|
|
'stabilizedFamilies' => $stabilizedFamilies,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $familyAttribution
|
|
* @param list<array<string, mixed>> $inventory
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function buildHeavyGovernanceInventoryCoverage(array $familyAttribution, array $inventory, float $laneSeconds): array
|
|
{
|
|
$requiredFamilyIds = [];
|
|
$coveredSeconds = 0.0;
|
|
|
|
foreach ($familyAttribution as $entry) {
|
|
$requiredFamilyIds[] = (string) $entry['familyId'];
|
|
$coveredSeconds += (float) ($entry['totalWallClockSeconds'] ?? 0.0);
|
|
|
|
if (count($requiredFamilyIds) >= 5 && ($laneSeconds <= 0.0 || ($coveredSeconds / $laneSeconds) >= 0.8)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
$inventoryFamilyIds = array_values(array_map(static fn (array $entry): string => $entry['familyId'], $inventory));
|
|
$coveredFamilyIds = array_values(array_intersect($requiredFamilyIds, $inventoryFamilyIds));
|
|
$coveredRuntimeSeconds = array_reduce(
|
|
$familyAttribution,
|
|
static function (float $carry, array $entry) use ($coveredFamilyIds): float {
|
|
if (! in_array((string) $entry['familyId'], $coveredFamilyIds, true)) {
|
|
return $carry;
|
|
}
|
|
|
|
return $carry + (float) ($entry['totalWallClockSeconds'] ?? 0.0);
|
|
},
|
|
0.0,
|
|
);
|
|
$coveredRuntimePercent = $laneSeconds > 0.0
|
|
? round(($coveredRuntimeSeconds / $laneSeconds) * 100, 6)
|
|
: 0.0;
|
|
|
|
return [
|
|
'requiredFamilyCount' => count($requiredFamilyIds),
|
|
'requiredFamilyIds' => $requiredFamilyIds,
|
|
'inventoryFamilyCount' => count($inventoryFamilyIds),
|
|
'inventoryFamilyIds' => $inventoryFamilyIds,
|
|
'coveredFamilyIds' => $coveredFamilyIds,
|
|
'coveredRuntimeSeconds' => round($coveredRuntimeSeconds, 6),
|
|
'coveredRuntimePercent' => $coveredRuntimePercent,
|
|
'meetsInclusionRule' => count($coveredFamilyIds) === count($requiredFamilyIds),
|
|
'topHotspots' => array_slice($familyAttribution, 0, 10),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $report
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function budgetPayload(array $report): array
|
|
{
|
|
return [
|
|
'laneId' => $report['laneId'],
|
|
'artifactDirectory' => $report['artifactDirectory'],
|
|
'wallClockSeconds' => $report['wallClockSeconds'],
|
|
'budgetThresholdSeconds' => $report['budgetThresholdSeconds'],
|
|
'budgetBaselineSource' => $report['budgetBaselineSource'],
|
|
'budgetEnforcement' => $report['budgetEnforcement'],
|
|
'budgetLifecycleState' => $report['budgetLifecycleState'],
|
|
'budgetStatus' => $report['budgetStatus'],
|
|
'classificationAttribution' => $report['classificationAttribution'],
|
|
'familyAttribution' => $report['familyAttribution'],
|
|
'budgetEvaluations' => $report['budgetEvaluations'],
|
|
'familyBudgetEvaluations' => $report['familyBudgetEvaluations'],
|
|
'budgetContract' => $report['budgetContract'] ?? null,
|
|
'inventoryCoverage' => $report['inventoryCoverage'] ?? null,
|
|
'budgetSnapshots' => $report['budgetSnapshots'] ?? null,
|
|
'budgetOutcome' => $report['budgetOutcome'] ?? null,
|
|
'remainingOpenFamilies' => $report['remainingOpenFamilies'] ?? null,
|
|
'stabilizedFamilies' => $report['stabilizedFamilies'] ?? null,
|
|
'sharedFixtureSlimmingComparison' => $report['sharedFixtureSlimmingComparison'] ?? null,
|
|
'trendHistoryArtifact' => $report['trendHistoryArtifact'] ?? null,
|
|
'trendCurrentAssessment' => $report['trendCurrentAssessment'] ?? null,
|
|
'trendHotspotSnapshot' => $report['trendHotspotSnapshot'] ?? null,
|
|
'trendRecalibrationDecisions' => $report['trendRecalibrationDecisions'] ?? null,
|
|
'trendWarnings' => $report['trendWarnings'] ?? null,
|
|
'ciBudgetEvaluation' => $report['ciBudgetEvaluation'] ?? null,
|
|
'artifactPublication' => $report['artifactPublication'] ?? null,
|
|
'ciSummary' => $report['ciSummary'] ?? null,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $report
|
|
* @param array{junit: string, summary: string, budget: string, report: string, profile: string, trendHistory: string} $artifactPaths
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function buildTrendHistoryArtifact(array $report, array $artifactPaths): array
|
|
{
|
|
$laneId = (string) $report['laneId'];
|
|
$existingArtifact = self::loadTrendHistoryArtifact($laneId, (string) $report['artifactDirectory']);
|
|
$existingDecisions = array_values(array_filter(
|
|
$existingArtifact['recalibrationDecisions'] ?? [],
|
|
static fn (mixed $decision): bool => is_array($decision),
|
|
));
|
|
$policy = TestLaneManifest::laneTrendPolicy(
|
|
$laneId,
|
|
$report['ciContext']['workflowId'] ?? null,
|
|
$report['ciContext']['triggerClass'] ?? null,
|
|
);
|
|
$baselineReference = self::resolveBaselineReference($report, $existingArtifact['history'] ?? [], $existingDecisions);
|
|
$currentRecord = self::buildTrendRecord($report, $artifactPaths, $baselineReference);
|
|
$history = self::mergeTrendHistory($currentRecord, $existingArtifact['history'] ?? [], (int) $policy['retentionLimit']);
|
|
$comparisonWindow = self::buildComparisonWindow($currentRecord, $history, $policy);
|
|
$assessment = self::buildTrendAssessment($currentRecord, $comparisonWindow, $policy);
|
|
$hotspotSnapshot = self::buildHotspotSnapshot(
|
|
$currentRecord,
|
|
$comparisonWindow['previousComparableRecord'] ?? null,
|
|
$policy,
|
|
);
|
|
$recordedIn = 'specs/211-runtime-trend-recalibration/spec.md';
|
|
$recalibrationDecisions = self::mergeRecalibrationDecisions(
|
|
$existingDecisions,
|
|
TestLaneBudget::automaticRecalibrationDecisions($laneId, $assessment, $history, $recordedIn),
|
|
);
|
|
$warnings = self::buildTrendWarnings($assessment, $hotspotSnapshot, $comparisonWindow);
|
|
|
|
return [
|
|
'schemaVersion' => TestLaneManifest::laneTrendContractVersion(),
|
|
'laneId' => $laneId,
|
|
'workflowProfile' => (string) $currentRecord['workflowId'],
|
|
'generatedAt' => (string) $report['finishedAt'],
|
|
'policy' => $policy,
|
|
'history' => $history,
|
|
'currentAssessment' => $assessment,
|
|
'hotspotSnapshot' => $hotspotSnapshot,
|
|
'recalibrationDecisions' => $recalibrationDecisions,
|
|
'warnings' => $warnings,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $history
|
|
* @param list<array<string, mixed>> $recalibrationDecisions
|
|
* @return array{seconds: float|null, source: string|null}
|
|
*/
|
|
private static function resolveBaselineReference(array $report, array $history, array $recalibrationDecisions): array
|
|
{
|
|
foreach ($recalibrationDecisions as $decision) {
|
|
if (($decision['targetType'] ?? null) !== 'baseline' || ($decision['decisionStatus'] ?? null) !== 'approved') {
|
|
continue;
|
|
}
|
|
|
|
if (($decision['proposedValueSeconds'] ?? null) === null) {
|
|
continue;
|
|
}
|
|
|
|
return [
|
|
'seconds' => round((float) $decision['proposedValueSeconds'], 6),
|
|
'source' => (string) ($decision['recordedIn'] ?? 'approved-baseline'),
|
|
];
|
|
}
|
|
|
|
if (is_array($report['sharedFixtureSlimmingComparison'] ?? null)) {
|
|
return [
|
|
'seconds' => round((float) $report['sharedFixtureSlimmingComparison']['baselineSeconds'], 6),
|
|
'source' => (string) ($report['sharedFixtureSlimmingComparison']['comparisonProfile'] ?? 'shared-fixture-baseline'),
|
|
];
|
|
}
|
|
|
|
foreach (array_reverse($history) as $record) {
|
|
if (! is_array($record)) {
|
|
continue;
|
|
}
|
|
|
|
if (($record['baselineSeconds'] ?? null) !== null) {
|
|
return [
|
|
'seconds' => round((float) $record['baselineSeconds'], 6),
|
|
'source' => (string) ($record['baselineSource'] ?? 'trend-history-anchor'),
|
|
];
|
|
}
|
|
|
|
if (($record['wallClockSeconds'] ?? null) !== null) {
|
|
return [
|
|
'seconds' => round((float) $record['wallClockSeconds'], 6),
|
|
'source' => 'trend-history-anchor',
|
|
];
|
|
}
|
|
}
|
|
|
|
return [
|
|
'seconds' => null,
|
|
'source' => null,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $report
|
|
* @param array{junit: string, summary: string, budget: string, report: string, profile: string, trendHistory: string} $artifactPaths
|
|
* @param array{seconds: float|null, source: string|null} $baselineReference
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function buildTrendRecord(array $report, array $artifactPaths, array $baselineReference): array
|
|
{
|
|
$laneId = (string) $report['laneId'];
|
|
$workflowId = (string) ($report['ciContext']['workflowId'] ?? sprintf('local-%s', $laneId));
|
|
$triggerClass = (string) ($report['ciContext']['triggerClass'] ?? 'local');
|
|
$runRef = self::currentRunRef($laneId, (string) $report['finishedAt'], (float) $report['wallClockSeconds']);
|
|
$budgetEvaluation = is_array($report['ciBudgetEvaluation'] ?? null)
|
|
? $report['ciBudgetEvaluation']
|
|
: [
|
|
'budgetStatus' => (string) ($report['budgetStatus'] ?? 'within-budget'),
|
|
'blockingStatus' => 'informational',
|
|
];
|
|
|
|
return array_filter([
|
|
'runRef' => $runRef,
|
|
'laneId' => $laneId,
|
|
'workflowId' => $workflowId,
|
|
'triggerClass' => $triggerClass,
|
|
'generatedAt' => (string) $report['finishedAt'],
|
|
'wallClockSeconds' => round((float) $report['wallClockSeconds'], 6),
|
|
'baselineSeconds' => $baselineReference['seconds'] !== null ? round((float) $baselineReference['seconds'], 6) : null,
|
|
'baselineSource' => $baselineReference['source'],
|
|
'budgetSeconds' => round((float) $report['budgetThresholdSeconds'], 6),
|
|
'budgetStatus' => (string) ($budgetEvaluation['budgetStatus'] ?? $report['budgetStatus'] ?? 'within-budget'),
|
|
'blockingStatus' => (string) ($budgetEvaluation['blockingStatus'] ?? 'informational'),
|
|
'comparisonFingerprint' => self::comparisonFingerprint($laneId, $workflowId, $triggerClass),
|
|
'classificationTotals' => self::runtimeBucketsFromAttribution(
|
|
$report['classificationAttribution'] ?? [],
|
|
'classificationId',
|
|
),
|
|
'familyTotals' => self::runtimeBucketsFromAttribution(
|
|
$report['familyAttribution'] ?? [],
|
|
'familyId',
|
|
),
|
|
'hotspotFiles' => self::hotspotFileBuckets($report['slowestEntries'] ?? []),
|
|
'slowestEntries' => self::trendSlowestEntries($report['slowestEntries'] ?? []),
|
|
'artifactRefs' => [
|
|
'summary' => $artifactPaths['summary'],
|
|
'report' => $artifactPaths['report'],
|
|
'budget' => $artifactPaths['budget'],
|
|
'junit' => $artifactPaths['junit'],
|
|
'trendHistory' => $artifactPaths['trendHistory'],
|
|
],
|
|
], static fn (mixed $value): bool => $value !== null);
|
|
}
|
|
|
|
private static function currentRunRef(string $laneId, string $finishedAt, float $wallClockSeconds): string
|
|
{
|
|
$ciRunId = getenv('GITEA_RUN_ID') ?: getenv('GITHUB_RUN_ID') ?: null;
|
|
|
|
if (is_string($ciRunId) && $ciRunId !== '') {
|
|
return sprintf('%s-%s', $laneId, $ciRunId);
|
|
}
|
|
|
|
return sprintf(
|
|
'%s-%s-%s',
|
|
$laneId,
|
|
str_replace([':', '+'], ['-', '_'], $finishedAt),
|
|
str_replace('.', '-', sprintf('%0.6f', $wallClockSeconds)),
|
|
);
|
|
}
|
|
|
|
private static function comparisonFingerprint(string $laneId, string $workflowId, string $triggerClass): string
|
|
{
|
|
$inputs = TestLaneManifest::comparisonFingerprintInputs($laneId, $workflowId, $triggerClass);
|
|
|
|
return sha1(json_encode($inputs, JSON_THROW_ON_ERROR));
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $currentRecord
|
|
* @param list<array<string, mixed>> $existingHistory
|
|
* @return list<array<string, mixed>>
|
|
*/
|
|
private static function mergeTrendHistory(array $currentRecord, array $existingHistory, int $retentionLimit): array
|
|
{
|
|
$merged = [$currentRecord];
|
|
$seenRunRefs = [(string) $currentRecord['runRef'] => true];
|
|
|
|
foreach ($existingHistory as $record) {
|
|
if (! is_array($record)) {
|
|
continue;
|
|
}
|
|
|
|
$runRef = (string) ($record['runRef'] ?? '');
|
|
|
|
if ($runRef === '' || array_key_exists($runRef, $seenRunRefs)) {
|
|
continue;
|
|
}
|
|
|
|
$merged[] = $record;
|
|
$seenRunRefs[$runRef] = true;
|
|
|
|
if (count($merged) >= $retentionLimit) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $merged;
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $currentRecord
|
|
* @param list<array<string, mixed>> $history
|
|
* @param array<string, mixed> $policy
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function buildComparisonWindow(array $currentRecord, array $history, array $policy): array
|
|
{
|
|
$comparableRecords = [];
|
|
$excludedRecords = [];
|
|
$fingerprint = (string) $currentRecord['comparisonFingerprint'];
|
|
$comparisonWindowSize = (int) $policy['comparisonWindowSize'];
|
|
|
|
foreach ($history as $record) {
|
|
if (($record['comparisonFingerprint'] ?? null) !== $fingerprint) {
|
|
$excludedRecords[] = [
|
|
'runRef' => (string) ($record['runRef'] ?? 'unknown'),
|
|
'comparisonFingerprint' => (string) ($record['comparisonFingerprint'] ?? ''),
|
|
];
|
|
|
|
continue;
|
|
}
|
|
|
|
$comparableRecords[] = $record;
|
|
|
|
if (count($comparableRecords) >= $comparisonWindowSize) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
$windowStatus = 'stable';
|
|
|
|
if (count($comparableRecords) < (int) $policy['minimumComparableSamples']) {
|
|
$windowStatus = $excludedRecords !== []
|
|
? 'scope-changed'
|
|
: 'insufficient-history';
|
|
}
|
|
|
|
return [
|
|
'currentRecord' => $currentRecord,
|
|
'previousComparableRecord' => $comparableRecords[1] ?? null,
|
|
'comparableRecords' => $comparableRecords,
|
|
'excludedRecords' => $excludedRecords,
|
|
'windowStatus' => $windowStatus,
|
|
'sampleCount' => count($comparableRecords),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $currentRecord
|
|
* @param array<string, mixed> $comparisonWindow
|
|
* @param array<string, mixed> $policy
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function buildTrendAssessment(array $currentRecord, array $comparisonWindow, array $policy): array
|
|
{
|
|
$comparableRecords = $comparisonWindow['comparableRecords'];
|
|
$previousComparableRecord = $comparisonWindow['previousComparableRecord'];
|
|
$sampleCount = (int) $comparisonWindow['sampleCount'];
|
|
$varianceFloorSeconds = (float) $policy['varianceFloorSeconds'];
|
|
$nearBudgetHeadroomSeconds = (float) $policy['nearBudgetHeadroomSeconds'];
|
|
$currentSeconds = (float) $currentRecord['wallClockSeconds'];
|
|
$budgetSeconds = (float) $currentRecord['budgetSeconds'];
|
|
$budgetHeadroomSeconds = round($budgetSeconds - $currentSeconds, 6);
|
|
$previousSeconds = is_array($previousComparableRecord)
|
|
? (float) ($previousComparableRecord['wallClockSeconds'] ?? 0.0)
|
|
: null;
|
|
$baselineSeconds = ($currentRecord['baselineSeconds'] ?? null) !== null
|
|
? (float) $currentRecord['baselineSeconds']
|
|
: null;
|
|
$deltaToPreviousSeconds = $previousSeconds !== null
|
|
? round($currentSeconds - $previousSeconds, 6)
|
|
: null;
|
|
$deltaToBaselineSeconds = $baselineSeconds !== null
|
|
? round($currentSeconds - $baselineSeconds, 6)
|
|
: null;
|
|
$deltaToPreviousPercent = $previousSeconds !== null && $previousSeconds > 0.0
|
|
? round(($deltaToPreviousSeconds / $previousSeconds) * 100, 6)
|
|
: null;
|
|
$deltaToBaselinePercent = $baselineSeconds !== null && $baselineSeconds > 0.0
|
|
? round(($deltaToBaselineSeconds / $baselineSeconds) * 100, 6)
|
|
: null;
|
|
$worseningStreak = self::worseningStreak($comparableRecords, $varianceFloorSeconds);
|
|
$varianceObservedSeconds = self::varianceObservedSeconds($comparableRecords);
|
|
$windowStatus = (string) $comparisonWindow['windowStatus'];
|
|
$noiseDetected = self::isNoisyWindow($comparableRecords, $varianceFloorSeconds);
|
|
$stablePlateau = $sampleCount >= (int) $policy['minimumComparableSamples']
|
|
&& $varianceObservedSeconds <= $varianceFloorSeconds
|
|
&& ($deltaToPreviousSeconds === null || abs($deltaToPreviousSeconds) <= $varianceFloorSeconds)
|
|
&& $deltaToBaselineSeconds !== null
|
|
&& abs($deltaToBaselineSeconds) > $varianceFloorSeconds;
|
|
$healthClass = 'healthy';
|
|
$recalibrationRecommendation = 'none';
|
|
$summaryLine = 'Lane runtime is stable and comfortably inside the documented budget.';
|
|
|
|
if ($windowStatus !== 'stable') {
|
|
$healthClass = 'unstable';
|
|
$recalibrationRecommendation = 'investigate';
|
|
$summaryLine = $windowStatus === 'scope-changed'
|
|
? 'Lane scope or workflow context changed, so older runs are not directly comparable yet.'
|
|
: 'Lane history is still building, so trend classification remains intentionally unstable.';
|
|
} elseif ($noiseDetected) {
|
|
$healthClass = 'unstable';
|
|
$windowStatus = 'noisy';
|
|
$recalibrationRecommendation = 'investigate';
|
|
$summaryLine = 'Recent samples disagree with each other, so the latest spike is treated as noise instead of a structural regression.';
|
|
} elseif ($budgetHeadroomSeconds < 0.0 && $worseningStreak >= 2) {
|
|
$healthClass = 'regressed';
|
|
$recalibrationRecommendation = 'review-budget';
|
|
$summaryLine = 'Comparable runs show repeated worsening and the lane is now over budget.';
|
|
} elseif ($worseningStreak >= 2) {
|
|
$healthClass = 'trending-worse';
|
|
$recalibrationRecommendation = $budgetHeadroomSeconds <= $nearBudgetHeadroomSeconds ? 'review-budget' : 'investigate';
|
|
$summaryLine = 'Comparable runs show sustained worsening above the documented variance floor.';
|
|
} elseif ($budgetHeadroomSeconds <= $nearBudgetHeadroomSeconds) {
|
|
$healthClass = 'budget-near';
|
|
$recalibrationRecommendation = 'investigate';
|
|
$summaryLine = 'Lane runtime remains under budget, but headroom is now thin enough to warrant attention.';
|
|
} elseif ($stablePlateau) {
|
|
$recalibrationRecommendation = 'review-baseline';
|
|
$summaryLine = 'Lane runtime has stabilized at a new level, so baseline review is reasonable if scope or infrastructure truth changed.';
|
|
}
|
|
|
|
return [
|
|
'healthClass' => $healthClass,
|
|
'recalibrationRecommendation' => $recalibrationRecommendation,
|
|
'budgetHeadroomSeconds' => $budgetHeadroomSeconds,
|
|
'deltaToPreviousSeconds' => $deltaToPreviousSeconds,
|
|
'deltaToPreviousPercent' => $deltaToPreviousPercent,
|
|
'deltaToBaselineSeconds' => $deltaToBaselineSeconds,
|
|
'deltaToBaselinePercent' => $deltaToBaselinePercent,
|
|
'worseningStreak' => $worseningStreak,
|
|
'varianceObservedSeconds' => $varianceObservedSeconds,
|
|
'windowStatus' => $windowStatus,
|
|
'sampleCount' => $sampleCount,
|
|
'previousComparableRunRef' => is_array($previousComparableRecord)
|
|
? (string) ($previousComparableRecord['runRef'] ?? '')
|
|
: null,
|
|
'summaryLine' => $summaryLine,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $currentRecord
|
|
* @param array<string, mixed>|null $previousComparableRecord
|
|
* @param array<string, mixed> $policy
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function buildHotspotSnapshot(array $currentRecord, ?array $previousComparableRecord, array $policy): array
|
|
{
|
|
if (! is_array($previousComparableRecord)
|
|
|| ($currentRecord['familyTotals'] ?? []) === []
|
|
|| ($previousComparableRecord['familyTotals'] ?? []) === []) {
|
|
return [
|
|
'evidenceAvailability' => 'unavailable',
|
|
'familyDeltas' => [],
|
|
'fileHotspots' => [],
|
|
'newEntrants' => [],
|
|
'droppedEntrants' => [],
|
|
];
|
|
}
|
|
|
|
$familyDeltas = self::deltaBuckets(
|
|
$currentRecord['familyTotals'],
|
|
$previousComparableRecord['familyTotals'] ?? [],
|
|
(int) $policy['hotspotFamilyLimit'],
|
|
);
|
|
$fileHotspots = self::deltaBuckets(
|
|
$currentRecord['hotspotFiles'] ?? [],
|
|
$previousComparableRecord['hotspotFiles'] ?? [],
|
|
(int) $policy['hotspotFileLimit'],
|
|
);
|
|
$currentHotspots = array_column($fileHotspots, 'name');
|
|
$previousHotspots = array_map(
|
|
static fn (array $bucket): string => (string) ($bucket['name'] ?? ''),
|
|
array_slice($previousComparableRecord['hotspotFiles'] ?? [], 0, (int) $policy['hotspotFileLimit']),
|
|
);
|
|
|
|
return [
|
|
'evidenceAvailability' => 'available',
|
|
'familyDeltas' => $familyDeltas,
|
|
'fileHotspots' => $fileHotspots,
|
|
'newEntrants' => array_values(array_diff($currentHotspots, $previousHotspots)),
|
|
'droppedEntrants' => array_values(array_diff($previousHotspots, $currentHotspots)),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* @param array<string, mixed> $assessment
|
|
* @param array<string, mixed> $hotspotSnapshot
|
|
* @param array<string, mixed> $comparisonWindow
|
|
* @return list<string>
|
|
*/
|
|
private static function buildTrendWarnings(array $assessment, array $hotspotSnapshot, array $comparisonWindow): array
|
|
{
|
|
$warnings = [];
|
|
|
|
if (($assessment['windowStatus'] ?? 'stable') !== 'stable') {
|
|
$warnings[] = sprintf('Trend window status is %s.', (string) $assessment['windowStatus']);
|
|
}
|
|
|
|
if (($hotspotSnapshot['evidenceAvailability'] ?? 'unavailable') !== 'available') {
|
|
$warnings[] = 'Hotspot evidence is unavailable for this cycle.';
|
|
}
|
|
|
|
if (($comparisonWindow['excludedRecords'] ?? []) !== []) {
|
|
$warnings[] = 'One or more recent records were excluded because the comparison fingerprint changed.';
|
|
}
|
|
|
|
return $warnings;
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $existingDecisions
|
|
* @param list<array<string, mixed>> $newDecisions
|
|
* @return list<array<string, mixed>>
|
|
*/
|
|
private static function mergeRecalibrationDecisions(array $existingDecisions, array $newDecisions): array
|
|
{
|
|
$merged = [];
|
|
$seen = [];
|
|
|
|
foreach (array_merge($newDecisions, $existingDecisions) as $decision) {
|
|
if (! is_array($decision)) {
|
|
continue;
|
|
}
|
|
|
|
$signature = implode('|', [
|
|
(string) ($decision['targetType'] ?? ''),
|
|
(string) ($decision['decisionStatus'] ?? ''),
|
|
(string) ($decision['rationaleCode'] ?? ''),
|
|
(string) ($decision['recordedIn'] ?? ''),
|
|
]);
|
|
|
|
if (isset($seen[$signature])) {
|
|
continue;
|
|
}
|
|
|
|
$merged[] = $decision;
|
|
$seen[$signature] = true;
|
|
|
|
if (count($merged) >= 6) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return $merged;
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $attribution
|
|
* @return list<array<string, mixed>>
|
|
*/
|
|
private static function runtimeBucketsFromAttribution(array $attribution, string $nameKey): array
|
|
{
|
|
return array_values(array_map(
|
|
static fn (array $entry): array => [
|
|
'name' => (string) ($entry[$nameKey] ?? 'unknown'),
|
|
'runtimeSeconds' => round((float) ($entry['totalWallClockSeconds'] ?? 0.0), 6),
|
|
],
|
|
$attribution,
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $slowestEntries
|
|
* @return list<array<string, mixed>>
|
|
*/
|
|
private static function hotspotFileBuckets(array $slowestEntries): array
|
|
{
|
|
$durations = [];
|
|
|
|
foreach ($slowestEntries as $entry) {
|
|
$file = (string) ($entry['filePath'] ?? '');
|
|
|
|
if ($file === '') {
|
|
continue;
|
|
}
|
|
|
|
$durations[$file] = round(($durations[$file] ?? 0.0) + (float) ($entry['wallClockSeconds'] ?? $entry['durationSeconds'] ?? 0.0), 6);
|
|
}
|
|
|
|
arsort($durations);
|
|
|
|
return array_values(array_map(
|
|
static fn (string $file, float $seconds): array => [
|
|
'name' => $file,
|
|
'runtimeSeconds' => $seconds,
|
|
],
|
|
array_keys($durations),
|
|
$durations,
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $slowestEntries
|
|
* @return list<array<string, mixed>>
|
|
*/
|
|
private static function trendSlowestEntries(array $slowestEntries): array
|
|
{
|
|
return array_values(array_map(
|
|
static fn (array $entry): array => [
|
|
'label' => (string) ($entry['label'] ?? $entry['subject'] ?? 'unknown'),
|
|
'runtimeSeconds' => round((float) ($entry['wallClockSeconds'] ?? $entry['durationSeconds'] ?? 0.0), 6),
|
|
'file' => isset($entry['filePath']) ? (string) $entry['filePath'] : null,
|
|
],
|
|
array_slice($slowestEntries, 0, 10),
|
|
));
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $currentBuckets
|
|
* @param list<array<string, mixed>> $previousBuckets
|
|
* @return list<array<string, mixed>>
|
|
*/
|
|
private static function deltaBuckets(array $currentBuckets, array $previousBuckets, int $limit): array
|
|
{
|
|
$currentMap = [];
|
|
$previousMap = [];
|
|
|
|
foreach ($currentBuckets as $bucket) {
|
|
$currentMap[(string) ($bucket['name'] ?? '')] = (float) ($bucket['runtimeSeconds'] ?? 0.0);
|
|
}
|
|
|
|
foreach ($previousBuckets as $bucket) {
|
|
$previousMap[(string) ($bucket['name'] ?? '')] = (float) ($bucket['runtimeSeconds'] ?? 0.0);
|
|
}
|
|
|
|
$names = array_values(array_filter(array_unique(array_merge(array_keys($currentMap), array_keys($previousMap)))));
|
|
$deltas = [];
|
|
|
|
foreach ($names as $name) {
|
|
$currentSeconds = round((float) ($currentMap[$name] ?? 0.0), 6);
|
|
$previousSeconds = round((float) ($previousMap[$name] ?? 0.0), 6);
|
|
$deltaSeconds = round($currentSeconds - $previousSeconds, 6);
|
|
$deltaPercent = $previousSeconds > 0.0
|
|
? round(($deltaSeconds / $previousSeconds) * 100, 6)
|
|
: null;
|
|
|
|
$deltas[] = [
|
|
'name' => $name,
|
|
'currentSeconds' => $currentSeconds,
|
|
'previousSeconds' => $previousSeconds,
|
|
'deltaSeconds' => $deltaSeconds,
|
|
'deltaPercent' => $deltaPercent,
|
|
'direction' => $deltaSeconds > 0.0 ? 'up' : ($deltaSeconds < 0.0 ? 'down' : 'flat'),
|
|
];
|
|
}
|
|
|
|
usort($deltas, static fn (array $left, array $right): int => abs((float) $right['deltaSeconds']) <=> abs((float) $left['deltaSeconds']));
|
|
|
|
return array_slice($deltas, 0, $limit);
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $comparableRecords
|
|
*/
|
|
private static function worseningStreak(array $comparableRecords, float $varianceFloorSeconds): int
|
|
{
|
|
$streak = 0;
|
|
|
|
for ($index = 0; $index < count($comparableRecords) - 1; $index++) {
|
|
$currentSeconds = (float) ($comparableRecords[$index]['wallClockSeconds'] ?? 0.0);
|
|
$previousSeconds = (float) ($comparableRecords[$index + 1]['wallClockSeconds'] ?? 0.0);
|
|
|
|
if (($currentSeconds - $previousSeconds) <= $varianceFloorSeconds) {
|
|
break;
|
|
}
|
|
|
|
$streak++;
|
|
}
|
|
|
|
return $streak;
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $comparableRecords
|
|
*/
|
|
private static function varianceObservedSeconds(array $comparableRecords): float
|
|
{
|
|
$seconds = array_values(array_map(
|
|
static fn (array $record): float => (float) ($record['wallClockSeconds'] ?? 0.0),
|
|
$comparableRecords,
|
|
));
|
|
|
|
if ($seconds === []) {
|
|
return 0.0;
|
|
}
|
|
|
|
return round(max($seconds) - min($seconds), 6);
|
|
}
|
|
|
|
/**
|
|
* @param list<array<string, mixed>> $comparableRecords
|
|
*/
|
|
private static function isNoisyWindow(array $comparableRecords, float $varianceFloorSeconds): bool
|
|
{
|
|
if (count($comparableRecords) < 3) {
|
|
return false;
|
|
}
|
|
|
|
$directions = [];
|
|
|
|
for ($index = 0; $index < count($comparableRecords) - 1; $index++) {
|
|
$currentSeconds = (float) ($comparableRecords[$index]['wallClockSeconds'] ?? 0.0);
|
|
$previousSeconds = (float) ($comparableRecords[$index + 1]['wallClockSeconds'] ?? 0.0);
|
|
$deltaSeconds = round($currentSeconds - $previousSeconds, 6);
|
|
|
|
if (abs($deltaSeconds) <= $varianceFloorSeconds) {
|
|
continue;
|
|
}
|
|
|
|
$directions[] = $deltaSeconds > 0.0 ? 'up' : 'down';
|
|
}
|
|
|
|
return in_array('up', $directions, true) && in_array('down', $directions, true);
|
|
}
|
|
|
|
/**
|
|
* @return array<string, mixed>
|
|
*/
|
|
private static function loadTrendHistoryArtifact(string $laneId, ?string $artifactDirectory = null): array
|
|
{
|
|
$artifactPaths = self::artifactPaths($laneId, $artifactDirectory);
|
|
$trendHistoryPath = TestLaneManifest::absolutePath($artifactPaths['trendHistory']);
|
|
|
|
if (! is_file($trendHistoryPath)) {
|
|
return [];
|
|
}
|
|
|
|
$decoded = json_decode((string) file_get_contents($trendHistoryPath), true);
|
|
|
|
return is_array($decoded) ? $decoded : [];
|
|
}
|
|
|
|
private static function resolveInputPath(string $path): string
|
|
{
|
|
if (str_starts_with($path, DIRECTORY_SEPARATOR)) {
|
|
return $path;
|
|
}
|
|
|
|
return self::repositoryRoot().DIRECTORY_SEPARATOR.ltrim($path, DIRECTORY_SEPARATOR);
|
|
}
|
|
|
|
private static function findTrendHistoryInDirectory(string $laneId, string $bundleDirectory): ?string
|
|
{
|
|
$candidates = [
|
|
sprintf('%s.trend-history.json', $laneId),
|
|
sprintf('%s-latest.trend-history.json', $laneId),
|
|
];
|
|
|
|
foreach ($candidates as $candidate) {
|
|
$candidatePath = rtrim($bundleDirectory, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR.$candidate;
|
|
|
|
if (is_file($candidatePath)) {
|
|
return $candidatePath;
|
|
}
|
|
}
|
|
|
|
$iterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($bundleDirectory));
|
|
|
|
foreach ($iterator as $file) {
|
|
if (! $file->isFile()) {
|
|
continue;
|
|
}
|
|
|
|
if (! in_array($file->getFilename(), $candidates, true)) {
|
|
continue;
|
|
}
|
|
|
|
return $file->getPathname();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static function findTrendHistoryInZip(string $laneId, ZipArchive $zip): ?string
|
|
{
|
|
$candidates = [
|
|
sprintf('%s.trend-history.json', $laneId),
|
|
sprintf('%s-latest.trend-history.json', $laneId),
|
|
];
|
|
|
|
for ($index = 0; $index < $zip->numFiles; $index++) {
|
|
$entryName = $zip->getNameIndex($index);
|
|
|
|
if (! is_string($entryName)) {
|
|
continue;
|
|
}
|
|
|
|
foreach ($candidates as $candidate) {
|
|
if (str_ends_with($entryName, $candidate)) {
|
|
return $entryName;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* @param array{junit: string, summary: string, budget: string, report: string, profile: string, trendHistory: string} $artifactPaths
|
|
* @return array<string, string>
|
|
*/
|
|
private static function artifactFileMap(array $artifactPaths): array
|
|
{
|
|
return [
|
|
'junit.xml' => $artifactPaths['junit'],
|
|
'summary.md' => $artifactPaths['summary'],
|
|
'budget.json' => $artifactPaths['budget'],
|
|
'report.json' => $artifactPaths['report'],
|
|
'profile.txt' => $artifactPaths['profile'],
|
|
'trend-history.json' => $artifactPaths['trendHistory'],
|
|
];
|
|
}
|
|
|
|
private static function stagedArtifactName(string $pattern, string $laneId, string $artifactFile): string
|
|
{
|
|
return str_replace(
|
|
['{laneId}', '{artifactFile}'],
|
|
[$laneId, $artifactFile],
|
|
$pattern,
|
|
);
|
|
}
|
|
|
|
private static function stagingRootPath(string $stagingDirectory): string
|
|
{
|
|
if (str_starts_with($stagingDirectory, DIRECTORY_SEPARATOR)) {
|
|
return $stagingDirectory;
|
|
}
|
|
|
|
return self::repositoryRoot().DIRECTORY_SEPARATOR.ltrim($stagingDirectory, '/');
|
|
}
|
|
|
|
private static function repositoryRoot(): string
|
|
{
|
|
return TestLaneManifest::repoRoot();
|
|
}
|
|
|
|
private static function ensureDirectory(string $directory): void
|
|
{
|
|
if (is_dir($directory)) {
|
|
return;
|
|
}
|
|
|
|
mkdir($directory, 0777, true);
|
|
}
|
|
}
|