kenshou-measure-0.1.0.0: src/Kenshou/Measure/Session.hs
module Kenshou.Measure.Session
( MeasureEnv (..),
MeasureConfig (..),
Measurement,
MeasurementReport (..),
measureEnvFromRunContext,
phasePlanFromCore,
measureConfigFromKnobs,
withMeasurement,
measurementPhaseClock,
measurementRecorder,
measurementConfig,
measurementEnv,
appendLoadReport,
measuredOutcome,
)
where
import Control.Exception (SomeException, mask, throwIO, try)
import Control.Monad (forM_, when)
import Data.Aeson (Value, toJSON)
import Data.IORef
import Data.Text (Text)
import Data.Word (Word64)
import Kenshou.Core.Context qualified as Core
import Kenshou.Core.Dimension (Dimensions (..), renderDurability)
import Kenshou.Core.Env.Postgres (PgSettingsSnapshot (..), PostgresEnv (..))
import Kenshou.Core.Id (Kind, ScenarioId (..), unSeed)
import Kenshou.Core.Knob (ResolvedKnobs)
import Kenshou.Core.Knob qualified as Knob
import Kenshou.Core.Log qualified as Log
import Kenshou.Core.Outcome (Outcome (..))
import Kenshou.Core.Phase qualified as Core
import Kenshou.Measure.Clock
import Kenshou.Measure.Health
import Kenshou.Measure.Histogram (HistogramConfig (..), defaultHistogramConfig)
import Kenshou.Measure.Load.Types (LoadReport)
import Kenshou.Measure.Phase
import Kenshou.Measure.Recorder
import Kenshou.Measure.Sampler
import Kenshou.Measure.Sampler.Postgres
import Kenshou.Measure.Summary
import System.FilePath (makeRelative)
data MeasureEnv = MeasureEnv
{ runDir :: FilePath,
seed :: Word64,
origin :: Origin,
processLabel :: Maybe Text,
scenarioKind :: Kind,
pgDurability :: Maybe Text,
specPhases :: Maybe PhasePlan,
knobs :: ResolvedKnobs,
dimensions :: Dimensions,
postgres :: Maybe PostgresEnv,
onPhase :: Phase -> Origin -> IO (),
registerSection :: Text -> Value -> IO (),
declareArtifact :: FilePath -> Text -> IO (),
logLine :: Text -> IO ()
}
data MeasureConfig = MeasureConfig
{ defaultPhases :: PhasePlan,
histogram :: HistogramConfig,
rawSamples :: RawSamplePolicy,
sampleIntervalMs :: Int,
intervalHistogramSeconds :: Word64,
postgres :: Maybe PgSamplerConfig,
extraSamplers :: [Sampler],
healthConfig :: HealthConfig
}
data Measurement = Measurement MeasureEnv PhaseClock Recorder MeasureConfig (IORef [LoadReport])
data MeasurementReport = MeasurementReport
{ recorder :: RecorderReport,
loads :: [LoadReport],
samplers :: SamplerReport,
summary :: MeasurementSummary,
health :: [HealthObservation]
}
measureEnvFromRunContext :: Core.RunContext -> IO MeasureEnv
measureEnvFromRunContext context = do
origin <- captureOrigin
let ScenarioId _ _ scenarioKind _ = context.scenario
Dimensions _ _ durability _ = context.dimensions
pure
MeasureEnv
{ runDir = context.outDir,
seed = unSeed context.seed,
origin,
processLabel = Nothing,
scenarioKind,
pgDurability = renderDurability <$> durability,
specPhases = Just (phasePlanFromCore context.phases),
knobs = context.knobs,
dimensions = context.dimensions,
postgres = context.env.postgres,
onPhase = \phase _ -> Log.logAt context.logger Log.Debug ("measurement phase " <> renderPhase phase) [],
registerSection = Core.putSummary context Core.Measurements,
declareArtifact = \path mediaType -> Core.declareMediaType context (makeRelative context.outDir path) mediaType,
logLine = \message -> Log.logAt context.logger Log.Info message []
}
phasePlanFromCore :: Core.PhasePlan -> PhasePlan
phasePlanFromCore plan =
PhasePlan
{ warmUp = seconds plan.warmUpSeconds,
steady = SteadyFor (seconds plan.steadySeconds),
drain = seconds plan.drainSeconds
}
where
seconds value = Nanos (floor (value * 1_000_000_000))
measureConfigFromKnobs :: Core.RunContext -> PhasePlan -> Either Text MeasureConfig
measureConfigFromKnobs context defaultPhases = do
rawSamples <- case Knob.knobText context.knobs (knobName "measure.raw-samples") of
"full" -> Right RawFull
"sampled" -> Right (RawSampled (fromIntegral (Knob.knobInt context.knobs (knobName "measure.raw-sample-one-in"))))
"off" -> Right RawOff
value -> Left ("unknown measure.raw-samples " <> value)
pure
MeasureConfig
{ defaultPhases,
histogram = defaultHistogramConfig {significantDigits = fromIntegral (Knob.knobInt context.knobs (knobName "measure.histogram-digits"))},
rawSamples,
sampleIntervalMs = fromIntegral (Knob.knobInt context.knobs (knobName "measure.sample-interval-ms")),
intervalHistogramSeconds = fromIntegral (Knob.knobInt context.knobs (knobName "measure.interval-histogram-seconds")),
postgres = postgresConfig,
extraSamplers = [],
healthConfig = defaultHealthConfig
}
where
postgresConfig =
fmap
( \environment ->
PgSamplerConfig
{ connectionString = environment.connectionString,
relations = [],
statements = case Knob.knobText context.knobs (knobName "measure.pg-statements") of
"off" -> PgStatementsOff
"periodic" -> PgStatementsPeriodic
_ -> PgStatementsSnapshots,
serverVersionNum = environment.snapshot.serverVersionNum
}
)
context.env.postgres
withMeasurement :: Core.RunContext -> MeasureConfig -> (Measurement -> IO value) -> IO (value, MeasurementReport)
withMeasurement context config action = mask \restore -> do
env <- measureEnvFromRunContext context
phaseClock <- newPhaseClock env.onPhase config.defaultPhases
recorder <-
newRecorder
RecorderConfig
{ runDir = env.runDir,
origin = env.origin,
processLabel = env.processLabel,
histogram = config.histogram,
rawSamples = config.rawSamples,
intervalHistogramSeconds = config.intervalHistogramSeconds,
declareArtifact = env.declareArtifact
}
phaseClock
loadReports <- newIORef []
let measurement = Measurement env phaseClock recorder config loadReports
sampling <-
startSampling
SamplerConfig
{ runDir = env.runDir,
origin = env.origin,
intervalMs = config.sampleIntervalMs,
postgres = config.postgres,
extraSamplers = config.extraSamplers,
phaseClock,
declareArtifact = env.declareArtifact,
logLine = env.logLine
}
result <- try (restore (action measurement))
phase <- currentPhase phaseClock
when (phase /= Done) (enterPhase phaseClock Done)
samplerReport <- stopSampling sampling
recorderReport <- finishRecorder recorder
loads <- readIORef loadReports
case result of
Left exception -> throwIO (exception :: SomeException)
Right value -> do
capturedNotices <- captureHealthNotices env.runDir
forM_ capturedNotices (\path -> env.declareArtifact path "application/x-ndjson")
summarized <- summarizeRunDirWithHealth config.healthConfig env.runDir
summary <- either (ioError . userError . show) pure summarized
env.registerSection "measurements" (toJSON summary)
pure (value, MeasurementReport recorderReport loads samplerReport summary summary.health)
measurementPhaseClock :: Measurement -> PhaseClock
measurementPhaseClock (Measurement _ phaseClock _ _ _) = phaseClock
measurementRecorder :: Measurement -> Recorder
measurementRecorder (Measurement _ _ recorder _ _) = recorder
measurementConfig :: Measurement -> MeasureConfig
measurementConfig (Measurement _ _ _ config _) = config
measurementEnv :: Measurement -> MeasureEnv
measurementEnv (Measurement env _ _ _ _) = env
appendLoadReport :: Measurement -> LoadReport -> IO ()
appendLoadReport (Measurement _ _ _ _ loadReports) report = modifyIORef' loadReports (<> [report])
measuredOutcome :: MeasurementReport -> Outcome -> Outcome
measuredOutcome report scenarioOutcome = case healthOutcome report.health of
Just InfrastructureFailure -> InfrastructureFailure
Just Inconclusive | scenarioOutcome `elem` [Passed, Failed] -> Inconclusive
_ -> scenarioOutcome
knobName :: Text -> Knob.KnobName
knobName = either (error . show) id . Knob.mkKnobName