packages feed

kenshou-core-0.1.0.0: src/Kenshou/Core/Context.hs

module Kenshou.Core.Context
  ( SummarySection (..),
    ArtifactDir (..),
    Observation (..),
    Environment (..),
    RunContext (..),
    RunState,
    PhaseTiming (..),
    InfrastructureError (..),
    newRunState,
    readRunState,
    requirePostgres,
    genFor,
    withPhase,
    putSummary,
    observe,
    artifactPath,
    declareMediaType,
  )
where

import Control.Exception (Exception, bracket_)
import Data.Aeson (ToJSON (..), Value, object, (.=))
import Data.IORef
import Data.Map.Strict (Map)
import Data.Map.Strict qualified as Map
import Data.Text (Text)
import Data.Time (UTCTime, getCurrentTime)
import Data.Word (Word64)
import GHC.Clock (getMonotonicTimeNSec)
import GHC.Stack (HasCallStack)
import Kenshou.Core.Dimension (Dimensions)
import Kenshou.Core.Env.Postgres (PostgresEnv)
import Kenshou.Core.Id (RunId, ScenarioId, Seed, deriveGen)
import Kenshou.Core.Knob (ResolvedKnobs)
import Kenshou.Core.Log (Logger, Severity)
import Kenshou.Core.Phase (PhaseName, PhasePlan)
import Kenshou.Core.Resource.Types (ProvisionedResource, ResourceName)
import Kenshou.Core.RunSpec (ComparisonMembership, EnvironmentSpec)
import System.Directory (createDirectoryIfMissing)
import System.FilePath ((</>))
import System.Random.SplitMix (SMGen)

data SummarySection = Measurements | Verdicts | Diagnosis | Telemetry deriving stock (Eq, Ord, Show)

data ArtifactDir = SamplesDir | SeriesDir | VerdictsDir | DiagnosisDir | LogsDir deriving stock (Eq, Ord, Show)

data Observation = Observation {source :: Text, severity :: Severity, message :: Text, at :: UTCTime} deriving stock (Eq, Show)

data Environment = Environment {postgres :: Maybe PostgresEnv, extraPostgres :: Map Text PostgresEnv, resources :: Map ResourceName ProvisionedResource}

data PhaseTiming = PhaseTiming
  { name :: PhaseName,
    startedAt :: UTCTime,
    endedAt :: UTCTime,
    startedMonotonicNs :: Word64,
    endedMonotonicNs :: Word64
  }
  deriving stock (Eq, Show)

instance ToJSON PhaseTiming where
  toJSON timing = object ["name" .= timing.name, "startedAt" .= timing.startedAt, "endedAt" .= timing.endedAt, "startedMonotonicNs" .= timing.startedMonotonicNs, "endedMonotonicNs" .= timing.endedMonotonicNs]

data RunState = RunState
  { summaries :: IORef (Map SummarySection (Map Text Value)),
    observations :: IORef [Observation],
    phaseTimings :: IORef [PhaseTiming],
    mediaTypes :: IORef (Map FilePath Text)
  }

data RunContext = RunContext
  { runId :: RunId,
    scenario :: ScenarioId,
    knobs :: ResolvedKnobs,
    dimensions :: Dimensions,
    seed :: Seed,
    phases :: PhasePlan,
    env :: Environment,
    environmentSpec :: EnvironmentSpec,
    comparison :: Maybe ComparisonMembership,
    outDir :: FilePath,
    logger :: Logger,
    state :: RunState
  }

newtype InfrastructureError = InfrastructureError Text deriving stock (Eq, Show)

instance Exception InfrastructureError

newRunState :: IO RunState
newRunState = RunState <$> newIORef Map.empty <*> newIORef [] <*> newIORef [] <*> newIORef Map.empty

readRunState :: RunState -> IO (Map SummarySection (Map Text Value), [Observation], [PhaseTiming], Map FilePath Text)
readRunState state = (,,,) <$> readIORef state.summaries <*> readIORef state.observations <*> readIORef state.phaseTimings <*> readIORef state.mediaTypes

requirePostgres :: (HasCallStack) => RunContext -> PostgresEnv
requirePostgres context = maybe (error "requirePostgres: scenario did not declare PostgreSQL") id context.env.postgres

genFor :: RunContext -> Text -> SMGen
genFor context = deriveGen context.seed

withPhase :: RunContext -> PhaseName -> IO value -> IO value
withPhase context phase action = do
  startedAt <- getCurrentTime
  startedMono <- getMonotonicTimeNSec
  action `finallyRecord` do
    endedAt <- getCurrentTime
    endedMono <- getMonotonicTimeNSec
    modifyIORef' context.state.phaseTimings (<> [PhaseTiming phase startedAt endedAt startedMono endedMono])
  where
    finallyRecord body cleanup = bracket_ (pure ()) cleanup body

putSummary :: RunContext -> SummarySection -> Text -> Value -> IO ()
putSummary context section key value = modifyIORef' context.state.summaries (Map.alter (Just . Map.insert key value . maybe Map.empty id) section)

observe :: RunContext -> Text -> Severity -> Text -> IO ()
observe context source severity message = do
  at <- getCurrentTime
  modifyIORef' context.state.observations (<> [Observation source severity message at])

artifactPath :: RunContext -> ArtifactDir -> FilePath -> IO FilePath
artifactPath context directory name = do
  let root = context.outDir </> artifactDir directory
  createDirectoryIfMissing True root
  pure (root </> name)

declareMediaType :: RunContext -> FilePath -> Text -> IO ()
declareMediaType context path mediaType = modifyIORef' context.state.mediaTypes (Map.insert path mediaType)

artifactDir :: ArtifactDir -> FilePath
artifactDir SamplesDir = "samples"
artifactDir SeriesDir = "series"
artifactDir VerdictsDir = "verdicts"
artifactDir DiagnosisDir = "diagnosis"
artifactDir LogsDir = "logs"