204 lines
8.3 KiB
PowerShell
204 lines
8.3 KiB
PowerShell
param(
|
|
[Parameter(Mandatory = $true)]
|
|
[string]$InputPath,
|
|
[string]$Scenario = "",
|
|
[string]$ThresholdConfigPath = "",
|
|
[string]$OutputPath = ""
|
|
)
|
|
|
|
Set-StrictMode -Version Latest
|
|
$ErrorActionPreference = "Stop"
|
|
|
|
function Resolve-AbsolutePath {
|
|
param(
|
|
[string]$Path,
|
|
[string]$BasePath
|
|
)
|
|
if ([System.IO.Path]::IsPathRooted($Path)) {
|
|
return [System.IO.Path]::GetFullPath($Path)
|
|
}
|
|
return [System.IO.Path]::GetFullPath((Join-Path $BasePath $Path))
|
|
}
|
|
|
|
function Convert-ToDouble {
|
|
param([object]$Value)
|
|
return [double]::Parse(
|
|
[string]$Value,
|
|
[System.Globalization.NumberStyles]::Float,
|
|
[System.Globalization.CultureInfo]::InvariantCulture)
|
|
}
|
|
|
|
function Get-Percentile {
|
|
param(
|
|
[double[]]$Values,
|
|
[double]$Percentile
|
|
)
|
|
if ($Values.Count -eq 0) { return 0.0 }
|
|
$sorted = @($Values | Sort-Object)
|
|
$index = [math]::Max(0, [math]::Ceiling($Percentile * $sorted.Count) - 1)
|
|
return [double]$sorted[$index]
|
|
}
|
|
|
|
function Get-PropertyValue {
|
|
param(
|
|
[object]$Object,
|
|
[string]$Name
|
|
)
|
|
if ($null -eq $Object) { return $null }
|
|
$property = $Object.PSObject.Properties[$Name]
|
|
if ($null -eq $property) { return $null }
|
|
return $property.Value
|
|
}
|
|
|
|
$repoRoot = [System.IO.Path]::GetFullPath((Join-Path $PSScriptRoot "..\..\.."))
|
|
$resolvedInput = Resolve-AbsolutePath -Path $InputPath -BasePath $repoRoot
|
|
if (-not (Test-Path -LiteralPath $resolvedInput -PathType Leaf)) {
|
|
throw "Performance CSV was not found: $resolvedInput"
|
|
}
|
|
|
|
$resolvedThresholds = if ([string]::IsNullOrWhiteSpace($ThresholdConfigPath)) {
|
|
Join-Path $repoRoot "internal/qa/config/performance-thresholds.json"
|
|
} else {
|
|
Resolve-AbsolutePath -Path $ThresholdConfigPath -BasePath $repoRoot
|
|
}
|
|
$thresholdConfig = Get-Content -LiteralPath $resolvedThresholds -Raw -Encoding UTF8 | ConvertFrom-Json
|
|
if ($thresholdConfig.schemaVersion -ne 1) {
|
|
throw "Unsupported performance threshold configuration version: $($thresholdConfig.schemaVersion)"
|
|
}
|
|
|
|
$allRows = @(Import-Csv -LiteralPath $resolvedInput)
|
|
$runningRows = @($allRows | Where-Object { $_.Status -eq "running" })
|
|
if ($runningRows.Count -eq 0) {
|
|
throw "Performance CSV contains no running samples: $resolvedInput"
|
|
}
|
|
|
|
if ([string]::IsNullOrWhiteSpace($Scenario)) {
|
|
$scenarioProperty = $runningRows[0].PSObject.Properties["Scenario"]
|
|
$Scenario = if ($null -ne $scenarioProperty -and -not [string]::IsNullOrWhiteSpace([string]$scenarioProperty.Value)) {
|
|
[string]$scenarioProperty.Value
|
|
} else {
|
|
[System.IO.Path]::GetFileNameWithoutExtension($resolvedInput)
|
|
}
|
|
}
|
|
|
|
$cpuValues = [double[]]@($runningRows | ForEach-Object { Convert-ToDouble $_.CpuPercent })
|
|
$workingSetValues = [double[]]@($runningRows | ForEach-Object { Convert-ToDouble $_.WorkingSetMB })
|
|
$privateMemoryValues = [double[]]@($runningRows | ForEach-Object { Convert-ToDouble $_.PrivateMemoryMB })
|
|
$handleValues = [double[]]@($runningRows | ForEach-Object { Convert-ToDouble $_.HandleCount })
|
|
$threadValues = [double[]]@($runningRows | ForEach-Object { Convert-ToDouble $_.ThreadCount })
|
|
|
|
$metrics = [ordered]@{
|
|
SampleCount = $runningRows.Count
|
|
AverageCpuPercent = [math]::Round(($cpuValues | Measure-Object -Average).Average, 2)
|
|
P95CpuPercent = [math]::Round((Get-Percentile -Values $cpuValues -Percentile 0.95), 2)
|
|
PeakCpuPercent = [math]::Round(($cpuValues | Measure-Object -Maximum).Maximum, 2)
|
|
StartWorkingSetMB = $workingSetValues[0]
|
|
EndWorkingSetMB = $workingSetValues[-1]
|
|
PeakWorkingSetMB = [math]::Round(($workingSetValues | Measure-Object -Maximum).Maximum, 2)
|
|
WorkingSetGrowthMB = [math]::Round($workingSetValues[-1] - $workingSetValues[0], 2)
|
|
StartPrivateMemoryMB = $privateMemoryValues[0]
|
|
EndPrivateMemoryMB = $privateMemoryValues[-1]
|
|
PeakPrivateMemoryMB = [math]::Round(($privateMemoryValues | Measure-Object -Maximum).Maximum, 2)
|
|
PrivateMemoryGrowthMB = [math]::Round($privateMemoryValues[-1] - $privateMemoryValues[0], 2)
|
|
HandleGrowth = [int]($handleValues[-1] - $handleValues[0])
|
|
PeakHandleCount = [int](($handleValues | Measure-Object -Maximum).Maximum)
|
|
ThreadGrowth = [int]($threadValues[-1] - $threadValues[0])
|
|
PeakThreadCount = [int](($threadValues | Measure-Object -Maximum).Maximum)
|
|
UnresponsiveSamples = @($runningRows | Where-Object { ([string]$_.Responding).ToLowerInvariant() -eq "false" }).Count
|
|
UnexpectedExit = @($allRows | Where-Object { $_.Status -eq "exited" }).Count -gt 0
|
|
}
|
|
|
|
$scenarioThresholds = Get-PropertyValue -Object $thresholdConfig.scenarios -Name $Scenario
|
|
$effectiveThresholds = @{}
|
|
foreach ($property in $thresholdConfig.defaults.PSObject.Properties) {
|
|
$effectiveThresholds[$property.Name] = $property.Value
|
|
}
|
|
if ($null -ne $scenarioThresholds) {
|
|
foreach ($property in $scenarioThresholds.PSObject.Properties) {
|
|
$effectiveThresholds[$property.Name] = $property.Value
|
|
}
|
|
}
|
|
|
|
$checks = New-Object System.Collections.Generic.List[object]
|
|
function Add-ThresholdCheck {
|
|
param(
|
|
[string]$Name,
|
|
[double]$Actual,
|
|
[string]$ThresholdName,
|
|
[string]$Unit
|
|
)
|
|
$threshold = $effectiveThresholds[$ThresholdName]
|
|
if ($null -eq $threshold) { return }
|
|
$limit = Convert-ToDouble $threshold
|
|
$checks.Add([pscustomobject]@{
|
|
Name = $Name
|
|
Passed = $Actual -le $limit
|
|
Actual = "$Actual$Unit"
|
|
Limit = "<= $limit$Unit"
|
|
})
|
|
}
|
|
|
|
$allowUnexpectedExit = [bool]$effectiveThresholds["allowUnexpectedExit"]
|
|
$checks.Add([pscustomobject]@{
|
|
Name = "Unexpected process exit"
|
|
Passed = $allowUnexpectedExit -or -not $metrics.UnexpectedExit
|
|
Actual = [string]$metrics.UnexpectedExit
|
|
Limit = if ($allowUnexpectedExit) { "allowed" } else { "False" }
|
|
})
|
|
Add-ThresholdCheck -Name "Unresponsive samples" -Actual $metrics.UnresponsiveSamples -ThresholdName "maxUnresponsiveSamples" -Unit ""
|
|
Add-ThresholdCheck -Name "Average CPU" -Actual $metrics.AverageCpuPercent -ThresholdName "maxAverageCpuPercent" -Unit "%"
|
|
Add-ThresholdCheck -Name "P95 CPU" -Actual $metrics.P95CpuPercent -ThresholdName "maxP95CpuPercent" -Unit "%"
|
|
Add-ThresholdCheck -Name "Private memory growth" -Actual $metrics.PrivateMemoryGrowthMB -ThresholdName "maxPrivateMemoryGrowthMB" -Unit " MB"
|
|
Add-ThresholdCheck -Name "Working set growth" -Actual $metrics.WorkingSetGrowthMB -ThresholdName "maxWorkingSetGrowthMB" -Unit " MB"
|
|
Add-ThresholdCheck -Name "Handle growth" -Actual $metrics.HandleGrowth -ThresholdName "maxHandleGrowth" -Unit ""
|
|
Add-ThresholdCheck -Name "Thread growth" -Actual $metrics.ThreadGrowth -ThresholdName "maxThreadGrowth" -Unit ""
|
|
|
|
$failedChecks = @($checks | Where-Object { -not $_.Passed })
|
|
$result = if ($failedChecks.Count -eq 0) { "PASS" } else { "FAIL" }
|
|
|
|
if ([string]::IsNullOrWhiteSpace($OutputPath)) {
|
|
$safeScenario = $Scenario -replace '[^a-zA-Z0-9._-]', '_'
|
|
$timestamp = Get-Date -Format "yyyyMMdd-HHmmss"
|
|
$OutputPath = "internal/qa/out/performance/$timestamp-$safeScenario.md"
|
|
}
|
|
$resolvedOutput = Resolve-AbsolutePath -Path $OutputPath -BasePath $repoRoot
|
|
$outputDirectory = Split-Path $resolvedOutput -Parent
|
|
if (-not (Test-Path -LiteralPath $outputDirectory)) {
|
|
New-Item -ItemType Directory -Path $outputDirectory -Force | Out-Null
|
|
}
|
|
|
|
$lines = New-Object System.Collections.Generic.List[string]
|
|
$lines.Add("# Performance Summary")
|
|
$lines.Add("")
|
|
$lines.Add("- Scenario: ``$Scenario``")
|
|
$lines.Add("- Result: **$result**")
|
|
$lines.Add("- Generated: $(Get-Date -Format 'yyyy-MM-dd HH:mm:ss zzz')")
|
|
$lines.Add("- Source CSV: ``$resolvedInput``")
|
|
$lines.Add("")
|
|
$lines.Add("## Metrics")
|
|
$lines.Add("")
|
|
$lines.Add("| Metric | Value |")
|
|
$lines.Add("| --- | ---: |")
|
|
foreach ($entry in $metrics.GetEnumerator()) {
|
|
$lines.Add("| $($entry.Key) | $($entry.Value) |")
|
|
}
|
|
$lines.Add("")
|
|
$lines.Add("## Threshold Checks")
|
|
$lines.Add("")
|
|
$lines.Add("| Check | Result | Actual | Limit |")
|
|
$lines.Add("| --- | --- | ---: | ---: |")
|
|
foreach ($check in $checks) {
|
|
$status = if ($check.Passed) { "PASS" } else { "FAIL" }
|
|
$lines.Add("| $($check.Name) | $status | $($check.Actual) | $($check.Limit) |")
|
|
}
|
|
$lines.Add("")
|
|
$lines.Add("Resource thresholds left as ``null`` are reported but not used as release gates. Calibrate them after a reviewed Release baseline is available.")
|
|
|
|
Set-Content -LiteralPath $resolvedOutput -Value $lines -Encoding UTF8
|
|
Write-Host "Performance report: $resolvedOutput"
|
|
Write-Host "Result: $result"
|
|
|
|
if ($failedChecks.Count -gt 0) {
|
|
exit 1
|
|
}
|